# packages

pkgId: 4ad4e7bbe2d76bfaa35e2d831c376c0a779c0d7b152d3d9e12cf2bdb1ad5efad
name: python-aqtinstall
arch: src
version: 3.1.18
epoch: 0
release: 1
summary: Another unofficial Qt installer
url: https://pypi.org/project/aqtinstall/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aqtinstall-3.1.18-1.src.rpm
checksum_type: sha256
description:
  - Release: |pypi|
  - Documentation: |docs|
  - Test status: |gha| and Coverage: |coveralls|
  - Project maturity |Package health|
  This is a utility alternative to the official graphical Qt installer, for using in CI environment
  where an interactive UI is not usable, or just on command line.
  It can automatically download prebuilt Qt binaries, documents and sources for target specified,
  when the versions are on Qt download mirror sites.
      Because it is an installer utility, it can download from Qt distribution site and its mirror.
      The site is operated by The Qt Company who may remove versions you may want to use that become end of support.
      Please don't blame us.
      This is NOT franchised with The Qt Company and The Qt Project. Please don't ask them about aqtinstall.


pkgId: e7e6c2ecc7bfc4c579018196c97b8d8c15d6511a19867636a4c173c2057fcd83
name: python-aqtp
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: Accurate Quantized Training library.
url: https://pypi.org/project/aqtp/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aqtp-0.8.1-1.src.rpm
checksum_type: sha256
description:
  AQT is a software library designed for easy tensor operation quantization in JAX.



    * Excellent quantized int8 model quality with no hand-tuning at all.
    * Excellent training speedup in production using contemporary ML accelerators.
    * Simple and flexible APIs suitable for both production and research.
    * AQT is a tensor op (matmul, einsum, conv, ...) quantization library.
      Does not make assumptions about the computations to be Neural Net.
    * AQT can be injected into any Jax computation.
      Well tested in:
      - [Flax](https://github.com/google/flax),
      - [Pax](https://github.com/google/paxml),
      - [MaxText](https://github.com/google/maxtext)
      - and other frameworks at Google.
    * AQT is designed for production workloads.
      It is well exemplified by these blog entries:
      - [Cloud ML AQT introduction](https://cloud.google.com/blog/products/compute/accurate-quantized-training-aqt-for-tpu-v5e/)
      - [50000+ TPU Cloud Ml training with AQT](https://cloud.google.com/blog/products/compute/the-worlds-largest-distributed-llm-training-job-on-tpu-v5e)
    * AQT is designed for research.
      It is well exemplified by these papers:
      - [Pareto-Optimal Quantized ResNet Is Mostly 4-bit](https://arxiv.org/abs/2105.03536)
      - [PokeBNN: A Binary Pursuit of Lightweight Accuracy](https://arxiv.org/abs/2112.00133)
      - [4-bit Conformer with Native Quantization Aware Training for Speech Recognition](https://arxiv.org/abs/2203.15952)
      - [Binarized Neural Machine Translation](https://arxiv.org/abs/2302.04907)
    * WYTIWYS (What you train is what you serve).
      AQT quantized models are bit-exact the same during training and serving.
      This side-steps the conventional issue of quantization-induced training-serving bias
      that typically happens for Post Training Quantization (PTQ).


  Let us know if you have any problem with aqt applications by filing an issue on Github.




  Tensor contraction operations in JAX-based neural network libraries, i.e., any form of (high-order) matrix multiplications, including but not limited to `jax.numpy.einsum` and `flax.linen.DenseGeneral`, call [lax.dot_general](https://jax.readthedocs.io/en/latest/_autosummary/jax.lax.dot_general.html) as its core computation. Quantizing a neural network in JAX simply requires substituting `lax.dot_general` with a quantized variant and keeping other parts as-is, which we call "quantization injection". JAX-based NN libraries, such as [Flax](https://github.com/google/flax) and [Pax](https://github.com/google/paxml), provide an API for this substitution when creating layers.

  In this section, we show how AQT produces a quantized `dot_general` and inject it into a neural network defined in JAX. The toy example below can be found in the [example colab](https://github.com/google/aqt/blob/main/aqt/jax/v2/examples/examples.ipynb).

  First, install the AQT package named as `aqtp` in PyPI.

  ```python

  !pip install aqtp
  ```

  Next, import `aqt.jax.v2`.
  Other [AQT versions](#aqt-versions) are obsolete.

  ```python

  import aqt.jax.v2.flax.aqt_flax as aqt
  import aqt.jax.v2.config as aqt_config
  import flax.linen as nn
  ```

  A [sample neural network](https://github.com/google/flax/blob/abab11fff54e229cb2691ebf71a7515abbd0a547/examples/lm1b/models.py#L170) defined in Flax looks like the following (as a toy example we use a simple MLP, but it can be any model):

  ```python
  class MlpBlock(nn.Module):
    config: aqt_config.DotGeneral | None

    @nn.compact
    def __call__(self, inputs):
      dot_general = aqt.AqtDotGeneral(self.config)
      x = nn.Dense(dot_general=dot_general, features=inputs.shape[-1] * 4)(inputs)
      x = nn.relu(x)
      x = nn.Dense(dot_general=dot_general, features=inputs.shape[-1])(x)
      return x
  ```

  AQT can quantize the model by simply replacing the `dot_general` in `nn.Dense` with a quantized dot_general created by the aqt configuration. The example specifies an AQT configuration that quantizes both forward and backward passes to int8. Now let's test it.

  ```python
  import jax
  import jax.numpy as jnp
  import numpy as np


  def gen_matrix(rows, columns, seed=0):
    np.random.seed(seed)
    return np.random.normal(size=(rows, columns)).reshape((rows, columns))

  inputs = gen_matrix(3, 4)


  def init_and_eval(name, mlp_block, init_seed=0, eval_seed=0):
    model = mlp_block.init(jax.random.PRNGKey(init_seed), inputs)
    out = mlp_block.apply(model, inputs, rngs={'params': jax.random.key(eval_seed)})
    print(f"{name}:\n", out)


  int8_config = aqt_config.fully_quantized(fwd_bits=8, bwd_bits=8)


  mlp_fp16 = MlpBlock(config=None)
  mlp_int8 = MlpBlock(config=int8_config)
  init_and_eval('mlp_fp16', mlp_fp16)
  init_and_eval('mlp_int8', mlp_int8)
  ```

  Results will be the following:

  ```
  mlp_fp16:
   [[ 0.720744    1.5375545  -2.6456933  -1.7605033 ]
   [-0.01541612  0.09728499 -1.5742414  -0.3737522 ]
   [ 0.4071759   1.1941448  -0.6982092  -0.48336366]]
  mlp_int8:
   [[ 0.7030779   1.5099456  -2.6334763  -1.7550919 ]
   [-0.00901393  0.08774488 -1.5644912  -0.3728472 ]
   [ 0.40121436  1.189411   -0.6939187  -0.48000643]]
  ```

  We can see that the quantized MLP produces similar outputs as the unquantized one.



  The example in [usage](#usage) uses the default configuration that quantizes both forward and backward passes to 8-bit, but AQT provides a much more flexible configuration system. The `DotGeneral` class can configure forward and backward tensor contraction operations separately.

  ```python
  @dataclasses.dataclass
  class DotGeneral:
    """Configuration of quantization of dot_general and its gradients."""
    fwd: DotGeneralRaw
    dlhs: DotGeneralRaw
    drhs: DotGeneralRaw
  ```

  In each `DotGeneral.DotGeneralRaw`, we can configure quantization of each input tensor of those ops separately and the hardware dtype to use (eg. jnp.bfloat16, jnp.float16, jnp.float8_e4m3fn, jnp.float8_e5m2, jnp.int8, jnp.int4).

  ```python
  @dataclasses.dataclass
  class DotGeneralRaw:
    """Configuration of quantization of one dot_general without gradient."""
    lhs: Tensor  # left hand side
    rhs: Tensor  # right hand side
    dg_in_dtype: Optional[DType]
    dg_accumulator_dtype: Optional[DType]
    local_aqt: Optional[LocalAqt]  # sharded quantization
  ```

  Inside config.Tensor we can configure the numerics used for each tensor, which includes number of bits, calibration algorithm, stochastic rounding, and many other quantization parameters.

  ```python
  @dataclasses.dataclass
  class Tensor:
    """Configuration of quantization of one tensor or one side of tensor op."""
    numerics: Numerics
    calib_shared_axes: Optional[list[int]]
    scale_stop_grad: bool
    calibration: calibration.Calibration  # calibration algorithm
    po2_scale: bool  # round calibration to power of 2
    use_fake_quant: bool
    use_fwd_quant: Optional[bool]  # use quantized fwd in the bwd pass
  ```



  This example demonstrates how to make a simple linear AQT quantizer.

  ```python
  from aqt.jax.v2 import aqt_quantizer
  from aqt.jax.v2 import calibration
  from aqt.jax.v2 import utils as aqt_utils
  from aqt.jax.v2.numerics import int_numerics

  q = aqt_quantizer.Quantizer(
      numerics=int_numerics.IntNumerics(
          bits=4,
          preserve_zero=True,
          preserve_max_val=True,
          clip=True,
          clip_gradient=True,
          round=True,
          noise_fn=None,
      ),
      calib_shared_axes=-1,
      scale_stop_grad=True,
      calibration=calibration.AbsMaxCalibration(),
      po2_scale=False,
      context=aqt_utils.Context(key=jax.random.PRNGKey(0), train_step=0))
  ```

  To view the quantized weights created by the quantizer, try quantizing a simple vector like so. Remember that these are the quantized values that are stored in memory for weight quantization.

  ```python
  x = jnp.linspace(-10, 10, 10)
  x_q, _ = q.quant(x, calibration_axes=-1)
  print(x_q.qvalue)
  ```

  To view the dequantized values that are used after multiplying the quantized values by the scale, use this code

  ```python
  print(x_q.dequant())
  ```

  To view the scales, simply call the scale attribute

  ```python
  print(x_q.scale)
  ```

  For a sanity check, we can assert that the scale in this example is simply equal to the dequantized values divided by the quantized values. (Hint: if you get an error check for nan values)

  ```python
  assert jnp.all(x_q.dequant() / x_q.qvalue == x_q.scale[0])
  ```

  Finally, we can plot the quantized values like so

  ```python
  import matplotlib.pyplot as plt
  plt.plot(x, x_q.qvalue)
  ```

  The specific quantizer parameters here are implemented in this tutorial are just for demonstration purposes and can be easily changed. Try altering the number of bits and see how the number of quantization steps changes accordingly.




  As of today there are several independent AQT implementations in this package:

  - [JAX Legacy AQT](https://github.com/google/aqt/blob/main/aqt/jax_legacy)
    Obsolete version of AQT still used by some customers.
  - [JAX AQTv1](https://github.com/google/aqt/blob/main/aqt/jax)
    Version of AQT that was developed with acceleration of NN inference in mind.
  - [TF AQTv1](https://github.com/google/aqt/blob/main/aqt/tensorflow)
    Tensorflow counterpart of JAX AQTv1.
  - [JAX AQTv2](https://github.com/google/aqt/blob/main/aqt/jax/v2)
    AQT implementing universal matmul quantization.

  AQTv2 is the recommended library.
  We plan to port remaining features from AQTv1 to AQTv2 and
  delete AQTv1 in early Q1 2024. Below we describe details about that.



  The most important AQTv2 (to be ported from AQTv1) missing features are:

   - https://github.com/google/aqt/issues/282
   - https://github.com/google/aqt/issues/280


  Lack of these features prevents AQTv2 from accelerating inference with small batch.
  The only option today is dynamic quantization where
  each tensor op is quantized independently and quantization scales are found just-in-time.



  AQTv2 speeds up training and fine-tuning.
  We verified 1.2x to 1.4x reduction in step time on 1B to 16B large Transformer
  models to a given quality on TPUs.

  Today in order to do it correctly one needs to understand that for each
  two-argument tensor op (matmul, einsum, conv) in the forward pass,
  there are two in the backward pass.
  One has to understand how to configure them.

  We will be updating config file with current best practices.



  Quantization is applied to both activations and weights right before a matmul.
  During training, gradients flow "through" the operation and update the latent
  floating-point weights.
  During model serving, however, re-quantizing weights is unnecessary and has large overhead because:

  1. Weights are stationary during serving. Recomputing weight quantization is a waste.
  2. Recomputing quantization requires loading the latent BF16 weights, which
  consumes 2x more memory bandwidth than loading INT8 weights.

  AQT provides a solution to the above problem, which is called "serving conversion".
  Serving conversion is a constant folding process that creates new variables in
  the checkpoint to store the folded INT8 weights.
  It requires running one dummy inference.

  Note that:

  1. Weights can be either lhs or rhs inputs to a matmul. AQT supports storing
  both in checkpoints, configured by [lhs_quant_mode and rhs_quant_mode](https://github.com/google/aqt/blob/eb445f8fd8cefac33eb965f0115ea2ac3d5cdff5/aqt/jax/v2/flax/aqt_flax.py#L97-L105).
  Users need to set the correct configuration themselves.
  2. In some cases where checkpoint variables require metadata such as sharding axis,
  users can configure [variable initializers](https://github.com/google/aqt/blob/eb445f8fd8cefac33eb965f0115ea2ac3d5cdff5/aqt/jax/v2/flax/aqt_flax.py#L98-L99) to fit their needs.

  At serving mode, AQT will look for the INT8 variables in a checkpoint.
  If found, it skips the weight quantization and returns INT8 variables
  as-is as inputs to matmul, thus saving the memory bandwidth and avoids recalculation.

  Applying the conversion to an unquantized floating-point model is
  equivalent to post-training quantization (PTQ) serving.
  Applying the conversion to a forward-only quantized AQT model is
  quantization-aware training (QAT) serving.
  In that case it is important to use the same AQT config during training and serving to maintain WYTIWYS.

  The [flax end-to-end example](https://github.com/google/aqt/blob/4c3f3d915a84089ff62a5c6cddf007949ed6fd96/aqt/jax/v2/examples/flax_e2e_model.py#L214-L235)
  provides a code snippet on how to perform serving conversion and model serving in AQT.



  Consider `matmul(a, w)` as an activation-weight matmul.
  Sometimes there is another transformation `T` on weights before passed into the matmul,
  i.e., `matmul(..., T(w))` is computed.
  In this case, quantizing weights directly, i.e., `matmul(..., T(Q(w)))`, can reduce the
  checkpoint size and save memory bandwidth, but it will not accelerate the matmul
  because `T` will likely return floats.
  In order to get matmul acceleration, the quantization function `Q` should be
  inserted just before matmul, i.e., `matmul(..., Q(T(w)))`.

  AQT pursues the goal of both compressing the checkpoint AND accelerating the matmul.
  This requires storing the entire `w_q = Q(T(w))` in the checkpoint and
  using it in serving directly, i.e., `matmul(..., w_q)`.

  Note that AQT provides a quantized `matmul_aqt`
  as a whole such that `matmul_aqt(..., T(w)) = matmul(..., Q(T(w)))`.
  `Q(T(w))` is not visible outside of `matmul_aqt`.
  The main reason is that `matmul_aqt` has custom gradient defined for it.



  In this section we:

    * show how to get quantization acceleration in JAX,
    * explain what AQT INT8 does under-the-hood (using the simplest INT8 configuration),
    * run the code on a simple example.

  Code in this section can be found and executable in the [example colab](https://github.com/google/aqt/blob/main/aqt/jax/v2/examples/examples.ipynb).
  Note that this section mainly explains how AQT works and why it can achieve a good quality. For AQT tutorial, user can refer to the [usage](#usage) section.

  The `matmul_true_int8` takes real INT8 as inputs, returns int32. The matmul computation `jnp.matmul` calls [lax.dot_general](https://jax.readthedocs.io/en/latest/_autosummary/jax.lax.dot_general.html) in its source, which is a JAX wrapper for [XLA DotGeneral](https://www.tensorflow.org/xla/operation_semantics#dotgeneral) op that implements all MXU ops (this is where we have int8 acceleration on TPUs) except convolution. This is how one can get hardware acceleration of quantized matmul in JAX.

  ```python
  import jax.numpy as jnp

  def matmul_true_int8(lhs, rhs):
    assert lhs.dtype == jnp.int8
    assert rhs.dtype == jnp.int8
    result = jnp.matmul(lhs, rhs, preferred_element_type=jnp.int32)
    assert result.dtype == jnp.int32
    return result
  ```

  Generate some random data:

  ```python
  batch_size = 3
  channels_in = 4
  channels_out = 5
  a = gen_matrix(batch_size, channels_in) # Activations
  w = gen_matrix(channels_in, channels_out) # Weights
  ```

  Below is how AQT works internally using the simplest INT8 configuration.
  Even though names such as "batch" and "channels" are used, "w" and "a", which are evocative of neural networks, one may note that `aqt_matmul_int8` algorithm is not DNN specific.

  ```python
  def aqt_matmul_int8(a, w):
    max_int8 = 127
    
    
    def quant_int8(x):
      return jnp.clip(jnp.round(x), -max_int8, max_int8).astype(jnp.int8)

    
    a_s = max_int8 / jnp.max(jnp.abs(a), axis=1, keepdims=True)
    w_s = max_int8 / jnp.max(jnp.abs(w), axis=0, keepdims=True)
    assert a_s.shape == (batch_size, 1) # shapes checked for illustration
    assert w_s.shape == (1, channels_out)

    
    result = matmul_true_int8(quant_int8(a * a_s), quant_int8(w * w_s)) / (a_s * w_s)
    assert result.shape == (batch_size, channels_out)

    return result
  ```

  Note that each example in a batch and each output channel will have their own separate scale. This reduces the effect of outliers in "w" and "a" to just one row or column, making a tighter calibration and much better quality of quantization. Comparing aqt_matmul_int8 to float matmul, their outputs are close.

  ```python
  print(f"jnp.matmul(a, w):\n", jnp.matmul(a, w))
  print(f"aqt_matmul_int8(a, w):\n", aqt_matmul_int8(a, w))
  ```

  ```

  jnp.matmul(a, w):
   [[ 3.6095254   5.8575077   1.9510972   4.732388    1.9792626 ]
   [ 4.335892    0.9743651   2.7298734   4.3540883   3.637487  ]
   [-0.07735002  2.7310796  -0.3519049   0.19912864 -1.2023292 ]]
  aqt_matmul_int8(a, w):
   [[ 3.5998788   5.8562713   1.9385538   4.7426414   1.9792401 ]
   [ 4.321886    0.99681264  2.737299    4.3591022   3.6352503 ]
   [-0.07714217  2.7415617  -0.35343346  0.20568734 -1.1974115 ]]
  ```


  We will be publishing AQT whitepaper soon.


pkgId: 267f512ecd3934855892307de7f8c3b6e2d31a611a960dadb9d1496086bab250
name: python-aqtp
arch: src
version: 0.8.2
epoch: 0
release: 1
summary: Accurate Quantized Training library.
url: https://pypi.org/project/aqtp/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aqtp-0.8.2-1.src.rpm
checksum_type: sha256
description:
  AQT is a software library designed for easy tensor operation quantization in JAX.



    * Excellent quantized int8 model quality with no hand-tuning at all.
    * Excellent training speedup in production using contemporary ML accelerators.
    * Simple and flexible APIs suitable for both production and research.
    * AQT is a tensor op (matmul, einsum, conv, ...) quantization library.
      Does not make assumptions about the computations to be Neural Net.
    * AQT can be injected into any Jax computation.
      Well tested in:
      - [Flax](https://github.com/google/flax),
      - [Pax](https://github.com/google/paxml),
      - [MaxText](https://github.com/google/maxtext)
      - and other frameworks at Google.
    * AQT is designed for production workloads.
      It is well exemplified by these blog entries:
      - [Cloud ML AQT introduction](https://cloud.google.com/blog/products/compute/accurate-quantized-training-aqt-for-tpu-v5e/)
      - [50000+ TPU Cloud Ml training with AQT](https://cloud.google.com/blog/products/compute/the-worlds-largest-distributed-llm-training-job-on-tpu-v5e)
    * AQT is designed for research.
      It is well exemplified by these papers:
      - [Pareto-Optimal Quantized ResNet Is Mostly 4-bit](https://arxiv.org/abs/2105.03536)
      - [PokeBNN: A Binary Pursuit of Lightweight Accuracy](https://arxiv.org/abs/2112.00133)
      - [4-bit Conformer with Native Quantization Aware Training for Speech Recognition](https://arxiv.org/abs/2203.15952)
      - [Binarized Neural Machine Translation](https://arxiv.org/abs/2302.04907)
    * WYTIWYS (What you train is what you serve).
      AQT quantized models are bit-exact the same during training and serving.
      This side-steps the conventional issue of quantization-induced training-serving bias
      that typically happens for Post Training Quantization (PTQ).


  Let us know if you have any problem with aqt applications by filing an issue on Github.




  Tensor contraction operations in JAX-based neural network libraries, i.e., any form of (high-order) matrix multiplications, including but not limited to `jax.numpy.einsum` and `flax.linen.DenseGeneral`, call [lax.dot_general](https://jax.readthedocs.io/en/latest/_autosummary/jax.lax.dot_general.html) as its core computation. Quantizing a neural network in JAX simply requires substituting `lax.dot_general` with a quantized variant and keeping other parts as-is, which we call "quantization injection". JAX-based NN libraries, such as [Flax](https://github.com/google/flax) and [Pax](https://github.com/google/paxml), provide an API for this substitution when creating layers.

  In this section, we show how AQT produces a quantized `dot_general` and inject it into a neural network defined in JAX. The toy example below can be found in the [example colab](https://github.com/google/aqt/blob/main/aqt/jax/v2/examples/examples.ipynb).

  First, install the AQT package named as `aqtp` in PyPI.

  ```python

  !pip install aqtp
  ```

  Next, import `aqt.jax.v2`.
  Other [AQT versions](#aqt-versions) are obsolete.

  ```python

  import aqt.jax.v2.flax.aqt_flax as aqt
  import aqt.jax.v2.config as aqt_config
  import flax.linen as nn
  ```

  A [sample neural network](https://github.com/google/flax/blob/abab11fff54e229cb2691ebf71a7515abbd0a547/examples/lm1b/models.py#L170) defined in Flax looks like the following (as a toy example we use a simple MLP, but it can be any model):

  ```python
  class MlpBlock(nn.Module):
    config: aqt_config.DotGeneral | None

    @nn.compact
    def __call__(self, inputs):
      dot_general = aqt.AqtDotGeneral(self.config)
      x = nn.Dense(dot_general=dot_general, features=inputs.shape[-1] * 4)(inputs)
      x = nn.relu(x)
      x = nn.Dense(dot_general=dot_general, features=inputs.shape[-1])(x)
      return x
  ```

  AQT can quantize the model by simply replacing the `dot_general` in `nn.Dense` with a quantized dot_general created by the aqt configuration. The example specifies an AQT configuration that quantizes both forward and backward passes to int8. Now let's test it.

  ```python
  import jax
  import jax.numpy as jnp
  import numpy as np


  def gen_matrix(rows, columns, seed=0):
    np.random.seed(seed)
    return np.random.normal(size=(rows, columns)).reshape((rows, columns))

  inputs = gen_matrix(3, 4)


  def init_and_eval(name, mlp_block, init_seed=0, eval_seed=0):
    model = mlp_block.init(jax.random.PRNGKey(init_seed), inputs)
    out = mlp_block.apply(model, inputs, rngs={'params': jax.random.key(eval_seed)})
    print(f"{name}:\n", out)


  int8_config = aqt_config.fully_quantized(fwd_bits=8, bwd_bits=8)


  mlp_fp16 = MlpBlock(config=None)
  mlp_int8 = MlpBlock(config=int8_config)
  init_and_eval('mlp_fp16', mlp_fp16)
  init_and_eval('mlp_int8', mlp_int8)
  ```

  Results will be the following:

  ```
  mlp_fp16:
   [[ 0.720744    1.5375545  -2.6456933  -1.7605033 ]
   [-0.01541612  0.09728499 -1.5742414  -0.3737522 ]
   [ 0.4071759   1.1941448  -0.6982092  -0.48336366]]
  mlp_int8:
   [[ 0.7030779   1.5099456  -2.6334763  -1.7550919 ]
   [-0.00901393  0.08774488 -1.5644912  -0.3728472 ]
   [ 0.40121436  1.189411   -0.6939187  -0.48000643]]
  ```

  We can see that the quantized MLP produces similar outputs as the unquantized one.



  The example in [usage](#usage) uses the default configuration that quantizes both forward and backward passes to 8-bit, but AQT provides a much more flexible configuration system. The `DotGeneral` class can configure forward and backward tensor contraction operations separately.

  ```python
  @dataclasses.dataclass
  class DotGeneral:
    """Configuration of quantization of dot_general and its gradients."""
    fwd: DotGeneralRaw
    dlhs: DotGeneralRaw
    drhs: DotGeneralRaw
  ```

  In each `DotGeneral.DotGeneralRaw`, we can configure quantization of each input tensor of those ops separately and the hardware dtype to use (eg. jnp.bfloat16, jnp.float16, jnp.float8_e4m3fn, jnp.float8_e5m2, jnp.int8, jnp.int4).

  ```python
  @dataclasses.dataclass
  class DotGeneralRaw:
    """Configuration of quantization of one dot_general without gradient."""
    lhs: Tensor  # left hand side
    rhs: Tensor  # right hand side
    dg_in_dtype: Optional[DType]
    dg_accumulator_dtype: Optional[DType]
    local_aqt: Optional[LocalAqt]  # sharded quantization
  ```

  Inside config.Tensor we can configure the numerics used for each tensor, which includes number of bits, calibration algorithm, stochastic rounding, and many other quantization parameters.

  ```python
  @dataclasses.dataclass
  class Tensor:
    """Configuration of quantization of one tensor or one side of tensor op."""
    numerics: Numerics
    calib_shared_axes: Optional[list[int]]
    scale_stop_grad: bool
    calibration: calibration.Calibration  # calibration algorithm
    po2_scale: bool  # round calibration to power of 2
    use_fake_quant: bool
    use_fwd_quant: Optional[bool]  # use quantized fwd in the bwd pass
  ```



  This example demonstrates how to make a simple linear AQT quantizer.

  ```python
  from aqt.jax.v2 import aqt_quantizer
  from aqt.jax.v2 import calibration
  from aqt.jax.v2 import utils as aqt_utils
  from aqt.jax.v2.numerics import int_numerics

  q = aqt_quantizer.Quantizer(
      numerics=int_numerics.IntSymmetric(
          bits=4,
          preserve_zero=True,
          preserve_max_val=True,
          clip=True,
          clip_gradient=True,
          round=True,
          noise_fn=None,
      ),
      calib_shared_axes=-1,
      scale_stop_grad=True,
      calibration=calibration.AbsMaxCalibration(),
      po2_scale=False,
      context=aqt_utils.Context(key=jax.random.PRNGKey(0), train_step=0))
  ```

  To view the quantized weights created by the quantizer, try quantizing a simple vector like so. Remember that these are the quantized values that are stored in memory for weight quantization.

  ```python
  x = jnp.linspace(-10, 10, 10)
  x_q, _ = q.quant(x, calibration_axes=-1)
  print(x_q.qvalue)
  ```

  To view the dequantized values that are used after multiplying the quantized values by the scale, use this code

  ```python
  print(x_q.dequant())
  ```

  To view the scales, simply call the scale attribute

  ```python
  print(x_q.scale)
  ```

  For a sanity check, we can assert that the scale in this example is simply equal to the dequantized values divided by the quantized values. (Hint: if you get an error check for nan values)

  ```python
  assert jnp.all(x_q.dequant() / x_q.qvalue == x_q.scale[0])
  ```

  Finally, we can plot the quantized values like so

  ```python
  import matplotlib.pyplot as plt
  plt.plot(x, x_q.qvalue)
  ```

  The specific quantizer parameters here are implemented in this tutorial are just for demonstration purposes and can be easily changed. Try altering the number of bits and see how the number of quantization steps changes accordingly.




  As of today there are several independent AQT implementations in this package:

  - [JAX Legacy AQT](https://github.com/google/aqt/blob/main/aqt/jax_legacy)
    Obsolete version of AQT still used by some customers.
  - [JAX AQTv1](https://github.com/google/aqt/blob/main/aqt/jax)
    Version of AQT that was developed with acceleration of NN inference in mind.
  - [TF AQTv1](https://github.com/google/aqt/blob/main/aqt/tensorflow)
    Tensorflow counterpart of JAX AQTv1.
  - [JAX AQTv2](https://github.com/google/aqt/blob/main/aqt/jax/v2)
    AQT implementing universal matmul quantization.

  AQTv2 is the recommended library.
  We plan to port remaining features from AQTv1 to AQTv2 and
  delete AQTv1 in early Q1 2024. Below we describe details about that.



  The most important AQTv2 (to be ported from AQTv1) missing features are:

   - https://github.com/google/aqt/issues/282
   - https://github.com/google/aqt/issues/280


  Lack of these features prevents AQTv2 from accelerating inference with small batch.
  The only option today is dynamic quantization where
  each tensor op is quantized independently and quantization scales are found just-in-time.



  AQTv2 speeds up training and fine-tuning.
  We verified 1.2x to 1.4x reduction in step time on 1B to 16B large Transformer
  models to a given quality on TPUs.

  Today in order to do it correctly one needs to understand that for each
  two-argument tensor op (matmul, einsum, conv) in the forward pass,
  there are two in the backward pass.
  One has to understand how to configure them.

  We will be updating config file with current best practices.



  Quantization is applied to both activations and weights right before a matmul.
  During training, gradients flow "through" the operation and update the latent
  floating-point weights.
  During model serving, however, re-quantizing weights is unnecessary and has large overhead because:

  1. Weights are stationary during serving. Recomputing weight quantization is a waste.
  2. Recomputing quantization requires loading the latent BF16 weights, which
  consumes 2x more memory bandwidth than loading INT8 weights.

  AQT provides a solution to the above problem, which is called "serving conversion".
  Serving conversion is a constant folding process that creates new variables in
  the checkpoint to store the folded INT8 weights.
  It requires running one dummy inference.

  Note that:

  1. Weights can be either lhs or rhs inputs to a matmul. AQT supports storing
  both in checkpoints, configured by [lhs_quant_mode and rhs_quant_mode](https://github.com/google/aqt/blob/eb445f8fd8cefac33eb965f0115ea2ac3d5cdff5/aqt/jax/v2/flax/aqt_flax.py#L97-L105).
  Users need to set the correct configuration themselves.
  2. In some cases where checkpoint variables require metadata such as sharding axis,
  users can configure [variable initializers](https://github.com/google/aqt/blob/eb445f8fd8cefac33eb965f0115ea2ac3d5cdff5/aqt/jax/v2/flax/aqt_flax.py#L98-L99) to fit their needs.

  At serving mode, AQT will look for the INT8 variables in a checkpoint.
  If found, it skips the weight quantization and returns INT8 variables
  as-is as inputs to matmul, thus saving the memory bandwidth and avoids recalculation.

  Applying the conversion to an unquantized floating-point model is
  equivalent to post-training quantization (PTQ) serving.
  Applying the conversion to a forward-only quantized AQT model is
  quantization-aware training (QAT) serving.
  In that case it is important to use the same AQT config during training and serving to maintain WYTIWYS.

  The [flax end-to-end example](https://github.com/google/aqt/blob/4c3f3d915a84089ff62a5c6cddf007949ed6fd96/aqt/jax/v2/examples/flax_e2e_model.py#L214-L235)
  provides a code snippet on how to perform serving conversion and model serving in AQT.



  Consider `matmul(a, w)` as an activation-weight matmul.
  Sometimes there is another transformation `T` on weights before passed into the matmul,
  i.e., `matmul(..., T(w))` is computed.
  In this case, quantizing weights directly, i.e., `matmul(..., T(Q(w)))`, can reduce the
  checkpoint size and save memory bandwidth, but it will not accelerate the matmul
  because `T` will likely return floats.
  In order to get matmul acceleration, the quantization function `Q` should be
  inserted just before matmul, i.e., `matmul(..., Q(T(w)))`.

  AQT pursues the goal of both compressing the checkpoint AND accelerating the matmul.
  This requires storing the entire `w_q = Q(T(w))` in the checkpoint and
  using it in serving directly, i.e., `matmul(..., w_q)`.

  Note that AQT provides a quantized `matmul_aqt`
  as a whole such that `matmul_aqt(..., T(w)) = matmul(..., Q(T(w)))`.
  `Q(T(w))` is not visible outside of `matmul_aqt`.
  The main reason is that `matmul_aqt` has custom gradient defined for it.



  In this section we:

    * show how to get quantization acceleration in JAX,
    * explain what AQT INT8 does under-the-hood (using the simplest INT8 configuration),
    * run the code on a simple example.

  Code in this section can be found and executable in the [example colab](https://github.com/google/aqt/blob/main/aqt/jax/v2/examples/examples.ipynb).
  Note that this section mainly explains how AQT works and why it can achieve a good quality. For AQT tutorial, user can refer to the [usage](#usage) section.

  The `matmul_true_int8` takes real INT8 as inputs, returns int32. The matmul computation `jnp.matmul` calls [lax.dot_general](https://jax.readthedocs.io/en/latest/_autosummary/jax.lax.dot_general.html) in its source, which is a JAX wrapper for [XLA DotGeneral](https://www.tensorflow.org/xla/operation_semantics#dotgeneral) op that implements all MXU ops (this is where we have int8 acceleration on TPUs) except convolution. This is how one can get hardware acceleration of quantized matmul in JAX.

  ```python
  import jax.numpy as jnp

  def matmul_true_int8(lhs, rhs):
    assert lhs.dtype == jnp.int8
    assert rhs.dtype == jnp.int8
    result = jnp.matmul(lhs, rhs, preferred_element_type=jnp.int32)
    assert result.dtype == jnp.int32
    return result
  ```

  Generate some random data:

  ```python
  batch_size = 3
  channels_in = 4
  channels_out = 5
  a = gen_matrix(batch_size, channels_in) # Activations
  w = gen_matrix(channels_in, channels_out) # Weights
  ```

  Below is how AQT works internally using the simplest INT8 configuration.
  Even though names such as "batch" and "channels" are used, "w" and "a", which are evocative of neural networks, one may note that `aqt_matmul_int8` algorithm is not DNN specific.

  ```python
  def aqt_matmul_int8(a, w):
    max_int8 = 127
    
    
    def quant_int8(x):
      return jnp.clip(jnp.round(x), -max_int8, max_int8).astype(jnp.int8)

    
    a_s = max_int8 / jnp.max(jnp.abs(a), axis=1, keepdims=True)
    w_s = max_int8 / jnp.max(jnp.abs(w), axis=0, keepdims=True)
    assert a_s.shape == (batch_size, 1) # shapes checked for illustration
    assert w_s.shape == (1, channels_out)

    
    result = matmul_true_int8(quant_int8(a * a_s), quant_int8(w * w_s)) / (a_s * w_s)
    assert result.shape == (batch_size, channels_out)

    return result
  ```

  Note that each example in a batch and each output channel will have their own separate scale. This reduces the effect of outliers in "w" and "a" to just one row or column, making a tighter calibration and much better quality of quantization. Comparing aqt_matmul_int8 to float matmul, their outputs are close.

  ```python
  print(f"jnp.matmul(a, w):\n", jnp.matmul(a, w))
  print(f"aqt_matmul_int8(a, w):\n", aqt_matmul_int8(a, w))
  ```

  ```

  jnp.matmul(a, w):
   [[ 3.6095254   5.8575077   1.9510972   4.732388    1.9792626 ]
   [ 4.335892    0.9743651   2.7298734   4.3540883   3.637487  ]
   [-0.07735002  2.7310796  -0.3519049   0.19912864 -1.2023292 ]]
  aqt_matmul_int8(a, w):
   [[ 3.5998788   5.8562713   1.9385538   4.7426414   1.9792401 ]
   [ 4.321886    0.99681264  2.737299    4.3591022   3.6352503 ]
   [-0.07714217  2.7415617  -0.35343346  0.20568734 -1.1974115 ]]
  ```


  We will be publishing AQT whitepaper soon.


pkgId: 22500eb8b7cc311ecc8bbf0e69eaf90cbe38913bc57ea65a35cbedcc27c40c65
name: python-aquacrop
arch: src
version: 3.0.10
epoch: 0
release: 1
summary: Soil-Crop-Water model based on AquaCrop-OS.
url: https://github.com/aquacropos/aquacrop
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aquacrop-3.0.10-1.src.rpm
checksum_type: sha256
description:
  Soil-Crop-Water model based on AquaCrop-OS.

  ![checks](https://badgen.net/github/checks/aquacropos/aquacrop)
  ![release](https://badgen.net/github/release/aquacropos/aquacrop)
  ![last-commit](https://badgen.net/github/last-commit/aquacropos/aquacrop)
  ![license](https://badgen.net/pypi/license/aquacrop)
  ![python-version](https://badgen.net/pypi/python/aquacrop)
  [![image](https://pepy.tech/badge/aquacrop)](https://pepy.tech/project/aquacrop)
  [![Downloads](https://pepy.tech/badge/aquacrop/month)](https://pepy.tech/project/aquacrop)


  ```python
  from aquacrop import AquaCropModel, Soil, Crop, InitialWaterContent
  from aquacrop.utils import prepare_weather, get_filepath

  weather_file_path = get_filepath('tunis_climate.txt')
  model_os = AquaCropModel(
              sim_start_time=f"{1979}/10/01",
              sim_end_time=f"{1985}/05/30",
              weather_df=prepare_weather(weather_file_path),
              soil=Soil(soil_type='SandyLoam'),
              crop=Crop('Wheat', planting_date='10/01'),
              initial_water_content=InitialWaterContent(value=['FC']),
          )
  model_os.run_model(till_termination=True)
  model_results = model_os.get_simulation_results().head()
  print(model_results)
  ```



  AquaCrop-OSPy is an open-source Python crop-water model developed by Tim Foster and others (Tom Kelly and Chris Bowden) within the Agriculture, Water and Climate research group at the University of Manchester. The AquaCrop-OSPy code has been developed with support from the the University of Manchester, Daugherty Water for Food Global Institute, Imperial College London, along with input from the United Nations Food and Agriculture Organization's (FAO) AquaCrop Core Development Group.

  Please note that AquaCrop-OSPy is not an official implementation or version of the FAO AquaCrop model. AquaCrop-OSPy currently mirrors most features available in version 7.1 of the official FAO AquaCrop model, with the exception of routines for salinity and fertility stress, weed management, and perennial herbaceous crops that are still to be developed. AquaCrop-OSPy has been rigorously tested to verify that the model reproduces accurately the calculations and outputs performed by the official FAO AquaCrop model. However, some bugs or errors may still be found. Please use the Issues tab to raise any issues encountered with the AquaCrop-OSPy. More details about the official FAO AquaCrop model on which AquaCrop-OSPy is based can be obtained <a href=https://www.fao.org/aquacrop> here </a>.

  For further information about the AquaCrop-OSPy model, you can consult the accompanying open-access journal paper on the code <a href=https://doi.org/10.1016/j.agwat.2021.106976> here </a>.
  There is also an extensive <a href=https://aquacropos.github.io/aquacrop/>documentation </a> for the model, along with a series of tutorials to help you get started with the Python code (see Quickstart below). AquaCrop-OSPy builds upon an earlier version of code developed in Matlab, more information about which can be found <a href=https://doi.org/10.1016/j.agwat.2016.11.015> here </a>.

  More information about the official FAO AquaCrop model on which AquaCrop-OSPy is based can be obtained <a href=https://www.fao.org/aquacrop> here </a>, where you can also access the official raw source AquaCrop code, compiled executables, and most recent code releases that are developed and provided by FAO.



  ```bash
  pip install aquacrop
  ```



  A number of tutorials has been created (more to be added in future) to help users jump straight in and run their first simulation. Run these tutorials instantly on Google Colab:

  1.  <a href=https://colab.research.google.com/github/aquacropos/aquacrop/blob/master/docs/notebooks/AquaCrop_OSPy_Notebook_1.ipynb>Running an AquaCrop-OSPy model</a>
  2.  <a href=https://colab.research.google.com/github/aquacropos/aquacrop/blob/master/docs/notebooks/AquaCrop_OSPy_Notebook_2.ipynb>Estimation of irrigation water demands</a>
  3.  <a href=https://colab.research.google.com/github/aquacropos/aquacrop/blob/master/docs/notebooks/AquaCrop_OSPy_Notebook_3.ipynb>Optimisation of irrigation management strategies</a>
  4.  <a href=https://colab.research.google.com/github/aquacropos/aquacrop/blob/master/docs/notebooks/AquaCrop_OSPy_Notebook_4.ipynb>Projection of climate change impacts</a>



  If you receive an error message such as "No module named aquacrop.scripts.initiate_library" or "ModuleNotFoundError: No module named 'aquacrop.solution.solution_root_zone_water'", please try the following troubleshooting steps:

  1. Run "python -m aquacrop.scripts.initiate_library" in your terminal, if this generates an error such as "RuntimeError: Attempted to compile AOT function without the compiler used by numpy.distutils present. Cannot find suitable msvc.", then you need to download and install an MSVC compiler such as the one included in Visual Studio build tools (see https://www.youtube.com/watch?v=p_R3tXSq0KI).

  2. If Step 1 doesn't help, then you can run aquacrop in development mode using the code below. This will turn off some function compilation, resulting in minor increases in runtime: <br>
  ```import os```<br>
  ```os.environ['DEVELOPMENT'] = 'DEVELOPMENT'```


pkgId: b83a1cfd674b7dc1efb1467f3cc0b93dc8d862bda868fc8ab178da2b2c690b8d
name: python-aqualogic
arch: src
version: 3.4
epoch: 0
release: 1
summary: Library for interfacing with a Hayward/Goldline AquaLogic/ProLogic pool controller.
url: https://github.com/swilson/aqualogic
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aqualogic-3.4-1.src.rpm
checksum_type: sha256
description:
  A python library to interface with Hayward/Goldline AquaLogic/ProLogic pool controllers. Note that the Goldline protocol uses RS-485 so a hardware interface that can provide the library with reader and writer file objects is required. The simplest solution for this is an RS-485 to Ethernet adapter connected via a socket.


pkgId: 4ba3b24fb1b7865e008f005948791bcbc76f04a7065dcda8a3616200c186671e
name: python-aquami
arch: src
version: 1.1.0
epoch: 0
release: 1
url: https://github.com/JStuckner/aquami
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aquami-1.1.0-1.src.rpm
checksum_type: sha256
summary:
  A module to extract quantitative microstructure information from micrographs of morphologically complex microstructures.

description:
  An open source package and GUI for automatic analysis of micrographs containing morphologically complex multiphase materials.  Designed especially for analysis of nanoporous metals and bicontinuous composites. Automatically returns quantitative mean and distribution measurements of microstructural features such as ligament/pore diameter, node-to-node length, particle/pore area, and area fraction.  Measurements and summaries can be conveniently output into excel and pdf files.
  For more information, see `this paper <https://doi.org/10.1016/j.commatsci.2017.08.012>`_.
  Installing
  ~~~~~~~~~~
  A standalone Windows version that does not require Python can be found `here <https://goo.gl/A8Y9Mq>`_.
  The easiest way to install the Python version is with pip.  In the command prompt type:
      pip install aquami
  Running the program
  ~~~~~~~~~~~~~~~~~~~
  Type the following in the command prompt pressing the <enter> key between lines:
  	python
  	from aquami import gui
  	gui.run()
  New in version 1.1.0
  ~~~~~~~~~~~~~~~~~~~~
  * Fix for Mac operating systems.
  * Updates for depreciated functions in numpy and matplotlib.


pkgId: 4cd14f1a0782be616d463c30a0bcb66bfb637391b60afc58624cb87364aabcfe
name: python-aquarel
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: Lightweight templating engine for matplotlib
url: https://github.com/lgienapp/aquarel
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aquarel-0.0.6-1.src.rpm
checksum_type: sha256
description:
  [![PyPi](https://img.shields.io/pypi/v/aquarel)](https://pypi.org/project/aquarel/)
  [![License](https://img.shields.io/github/license/lgienapp/aquarel)]()
  [![Documentation Status](https://readthedocs.org/projects/aquarel/badge/?version=latest)](https://aquarel.readthedocs.io/en/latest/?badge=latest)

  Aquarel is a lightweight templating engine and wrapper around Matplotlibs' `rcparams` to make styling plots simple.
  Aquarel templates can be defined programmatically and be serialized and shared in a JSON format.

  Full documentation is available at [aquarel.readthedocs.io](https://aquarel.readthedocs.io/en/latest/?badge=latest).



  Install via pip:

  ```sh
  python -m pip install aquarel
  ```





  Styles can be either applied globally

  ```python
  from aquarel import load_theme

  theme = load_theme("arctic_light")
  theme.apply()

  theme.apply_transforms()
  ```

  ...or with a context manager:

  ```python
  from aquarel import load_theme

  with load_theme("arctic_light"):
      figure = # ... plotting code here
  ```



  Themes may specify _transforms_. Transforms are functions applied on the finished plot to achieve aesthetics that are not possibly by means of `rcparams` only.
  For example, to trim the axes, one could apply the `trim` transform:

  ```python
  from aquarel import load_theme

  with load_theme("arctic_light").set_transforms(trim=True):
      figure = # ... plotting code here


  figure.savefig()
  ```

  However, there is one important thing to keep in mind: since transforms require the matplotlib figure/axes object to be present and finished, they have to be applied **after** the plotting code.
  When using a theme with a context manager, this is automatically done in the `__exit__` call. If global usage is desired, `Theme.apply_transforms()` has to be called after every figure.
  This also means that calls that make use of the finished figure, i.e. `plt.show` or `plt.savefig` have to commence after transform application, so **outside** the context manager.



  Besides loading a predefined theme, you can create a new theme

  ```python
  from aquarel import Theme

  theme = (
      Theme(name="demo", description="A demo theme.")
      .set_grid(draw=True, width=0.5)
      .set_font(family="monospace")
      .set_color(grid_color="blue")
  )
  ```

  ...modify an existing one

  ```python
  from aquarel import load_theme

  theme = (
      load_theme("arctic_light")
      .set_grid(width=2)
  )
  ```

  ...and write and load your custom styles to and from disk:

  ```python
  from aquarel import Theme

  theme = Theme.from_file("custom.json")
  theme.save("custom.json")
  ```

  If the simplified API of aquarel is not sufficient for your use-case, you can also directly modify the underlying `rcparams` with overrides:

  ```python
  from aquarel import load_theme

  theme = load_theme("arctic_light").set_overrides({
      "ytick.minor.visible": False,
      "xtick.minor.visible": True
  })
  ```



  aquarel ships with several pre-defined themes that are designed to showcase its templating capabilities.
  Add your own with a pull request!

  | Name            | Description                                                                                      | Preview                                                                              |
  | :-------------- | :----------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------- |
  | `arctic_dark`   | Frosty dark theme based on the [nord](https://github.com/arcticicestudio/nord) color scheme      | ![](https://github.com/lgienapp/aquarel/blob/main/assets/arctic_dark.png?raw=true)   |
  | `arctic_light`  | Frosty dark theme based on the [nord](https://github.com/arcticicestudio/nord) color scheme      | ![](https://github.com/lgienapp/aquarel/blob/main/assets/arctic_light.png?raw=true)  |
  | `boxy_dark`     | Dark theme with enclosing box and grid                                                           | ![](https://github.com/lgienapp/aquarel/blob/main/assets/boxy_dark.png?raw=true)     |
  | `boxy_light`    | Light theme with enclosing box and grid                                                          | ![](https://github.com/lgienapp/aquarel/blob/main/assets/boxy_light.png?raw=true)    |
  | `gruvbox_dark`  | Dark theme with pastel [retro groove colors](https://github.com/morhetz/gruvbox)                 | ![](https://github.com/lgienapp/aquarel/blob/main/assets/gruvbox_dark.png?raw=true)  |
  | `gruvbox_light` | Light theme with pastel [retro groove colors](https://github.com/morhetz/gruvbox)                | ![](https://github.com/lgienapp/aquarel/blob/main/assets/gruvbox_light.png?raw=true) |
  | `minimal_dark`  | Dark theme with minimal visual elements                                                          | ![](https://github.com/lgienapp/aquarel/blob/main/assets/minimal_dark.png?raw=true)  |
  | `minimal_light` | Light theme with minimal visual elements                                                         | ![](https://github.com/lgienapp/aquarel/blob/main/assets/minimal_light.png?raw=true) |
  | `scientific`    | Space-efficient and color-blind friendly theme for printing on paper                             | ![](https://github.com/lgienapp/aquarel/blob/main/assets/scientific.png?raw=true)    |
  | `umbra_dark`    | Balanced dark theme based on the [penumbra](https://github.com/nealmckee/penumbra) color scheme  | ![](https://github.com/lgienapp/aquarel/blob/main/assets/umbra_dark.png?raw=true)    |
  | `umbra_light`   | Balanced light theme based on the [penumbra](https://github.com/nealmckee/penumbra) color scheme | ![](https://github.com/lgienapp/aquarel/blob/main/assets/umbra_light.png?raw=true)   |





  `aquarel` is a wrapper around the stylesheets, so everything you can do with stylesheets can be achieved with `aquarel`. However there are some notable shortcomings of stylesheets that `aquarel` adresses:

  1. **On-the-fly templating** – the stylesheets are applied once and are then used for every plot in the current plotting context (py-file, notebook, ipython session, ...). `aquarel` takes a different approach here and aims to provide per-plot styling with optional temporary changes. The style `aquarel` applies lasts throughout the context manager (`with aquarel.Theme:`), and switches back to whatever is the global default style outside of it. This allows you to do plot-level temporary changes. You have one plot in your notebook that needs no minor ticks? just `with theme.set_ticks():` for this plot only.
  2. **Simplified templating**: matplotlib stylesheets have a lot of redundant keys for most applications. For example, you rarely want to have different colors for both axes; while possible with a stylefile, its cumbersome to change all the different keys to achieve a uniform look. `aquarel` simplifies this with e.x. a single `set_color(ticks="#eee")` call, which changes all related and relevant keys for ticks. Note that this simplifies the API, but does not restrict capabilities: the `set_overrides` method accepts every possible stylefile key if you want to access low-level styling.
  3. **Transforms**: some style elements, like trimmed axes, are not achievable with stylesheets alone (see README for more informations). `aquarel` defines a few of these transforms (and hopefully many more in the future), and makes them persistable and shareable through aquarel themes. Instead of having to apply a seaborn despine after every plot, you can have a global style that specifies a trim, and have consistent styling throughout with minimal code repetition.


pkgId: 4bb146ddc18887a270ca8ca8f8cde3b4cf8073092aee4c4fc3e28059d4bde025
name: python-aquarium-python-api
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: Aquarium python package
url: https://docs.fatfish.app/dev/python/index.html
rpm_license: gpl-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aquarium-python-api-2.1.0-1.src.rpm
checksum_type: sha256
description:
  ![aquarium-python-api](https://github.com/fatfish-lab/aquarium-python-api/blob/main/docs/source/_static/logo.png?raw=true)

  > Aquarium python API is a tool that allows [Aquarium Studio](https://fatfi.sh/aquarium) users to interact with there data from directly from Python.

  Aquarium Studio is developed by [Fatfish Lab](https://fatfi.sh)

  ```python

  from aquarium import Aquarium

  aq = Aquarium('https://your-aquarium-server')
  aq.connect(AQ_USER, AQ_PASSWORD)

  me = aq.get_current_user()
  my_tasks = me.get_tasks()
  ```


  This package is compatible with Python 2.7 and 3.7+

  ```python
  python -m pip install aquarium-python-api
  ```
  OR
  ```python
  python -m pip install git+https://github.com/fatfish-lab/aquarium-python-api.git
  ```



  Check our [documentation](https://docs.fatfish.app/dev/python/index.html) to find all the information you need.



  The repository is maintained by [Fatfish Lab](https://fatfi.sh)



  You can contact our team at [support@fatfi.sh](mailto:support@fatfi.sh).



  > Rather the package is compatible with python 2.7 and 3, the Sphinx documentation is using python 3.

  1. Clone this repository
  1. Setup a virtual env : `virtualenv pyaq`
     1. If needed, you can specify the version of python used in your virtual env : `virtualenv --python=/usr/bin/python3 pyaq3`
  1. Enable your virtual env : `source pyaq/bin/activate`
  1. Install local Aquarium package to your virtual env : `pip install -e /path/to/package/aquarium-python-api`



  1. `cd /path/to/package/aquarium-python-api/docs`
  2. `make html`



  This project uses the following license: GPL-3.0-only.
  See the license file to read it.


pkgId: f40d68018be53a41dd370b1d6bed57983166fba0c2d2dc5fdff99b1b1c78456b
name: python-aquasol
arch: src
version: 1.6.1
epoch: 0
release: 1
summary: Thermodynamic and physico-chemical properties for water and aqueous solutions
url: https://github.com/ovinc/aquasol
rpm_license: CeCILL-2.1
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aquasol-1.6.1-1.src.rpm
checksum_type: sha256
description:
  This package computes useful thermodynamic quantities for water and aqueous solutions (undersaturated, saturated and supersaturated). Is is divided in two modules: **water** (properties of pure water) and **solutions** (properties of aqueous solutions), which provide various functions to calculate properties of interest. There is also a list of useful constants in the *constants.py* module.
  It is also possible to just see plots of the properties by running the package directly from a shell console with
  ```bash
  python -m aquasol
  ```
  The package is under CeCILL-2.1 license, which is equivalent to GNU-GPL (see license file and information below)
  How to install:
  ```bash
  pip install aquasol
  ```


pkgId: 7bddc00bd2ae7543af14f7883c5065bdadce8db59358bc02b82feb13badcaef0
name: python-aquiche
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: Async cache in-memory
url: https://pypi.org/project/aquiche/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aquiche-1.3.1-1.src.rpm
checksum_type: sha256
description:
  Fast, unopinionated, minimalist cache decorator for [python](https://www.python.org).

  [<img alt="Link to the github repository" src="https://img.shields.io/badge/github-jammymalina/aquiche-8da0cb?style=for-the-badge&labelColor=555555&logo=github">](https://github.com/jammymalina/aquiche)
  [<img alt="Link to the build" src="https://img.shields.io/github/workflow/status/jammymalina/aquiche/CI?style=for-the-badge">](https://github.com/jammymalina/aquiche/actions?query=branch%3Amain+)
  [<img alt="Link to PyPi" src="https://img.shields.io/pypi/v/aquiche?style=for-the-badge">](https://pypi.org/project/aquiche)

  ```python
  import httpx
  from aquiche import alru_cache

  @alru_cache(wrap_async_exit_stack=True)
  async def get_client() -> httpx.AsyncClient:
      return httpx.AsyncClient(base_url="https://api.data.io")


  @alru_cache(expiration="10minutes")
  async def get_data(id: str) -> dict:
      client = await get_client()
      res = await client.get(f"/data/{id}")
      return res.json()

  async def main() -> None:
      data = await get_data("id1")
      print("Received the data!!!")
  ```



  This is a [python](https://www.python.org) module available through the
  [pypi registry](https://pypi.org).

  Before installing, [download and install Python](https://www.python.org/downloads).
  Python 3.8 or higher is required.

  Installation is done using the
  [`pip install` command](https://packaging.python.org/en/latest/tutorials/installing-packages):

  ```console
  $ pip install aquiche
  ```



  - Robust caching
  - Safe to use with both async and multithreaded applications
  - Works with both "sync" functions and async functions/coroutines
  - No cache stampede/cascading failure - no multiple redundant calls when your cache is being hit at the same time
  - Wide range of options for setting the expiration
  - Negative cache support
  - Focus on high performance
  - Contains typings
  - High test coverage



  The decorator is very similar to [`functools.lru_cache`](https://docs.python.org/3/library/functools.html#functools.lru_cache).

  Decorator to wrap a function with a memoizing callable that saves up to the maxsize most recent calls. It can save time when an expensive or IO bound function is periodically called with the same arguments. The decorator works both with sync and async functions. It is safe to use in multithreaded and async applications.

  Since a dictionary is used to cache results, the positional and keyword arguments to the function must be hashable or the key parameter has to be provided.

  Distinct argument patterns may be considered to be distinct calls with separate cache entries. For example, f(a=1, b=2) and f(b=2, a=1) differ in their keyword argument order and may have two separate cache entries. If you provide the key parameter the `str.format()` is used to generate the key. `Args` and `kwargs` are passed to the format function. Named `args` are passed to the function both as `args` and they are included in the `kwargs` as well. The special option "single key" can be used for the functions with no arguments or with only self/cls argument. In that case the key will have the same value no matter the `args` or `kwargs`.

  The wrapped function is instrumented with a `cache_parameters()` function that returns a dataclass showing the values for all the set parameters. This is for information purposes only. Mutating the values has no effect.

  To help measure the effectiveness of the cache and tune the maxsize parameter, the wrapped function is instrumented with a `cache_info()` function that returns a dataclass showing hits, misses, maxsize, current_size, and last_expiration_check. This function has to be awaited when the decorator is wrapping an async function.

  The decorator also provides a `cache_clear()` function for clearing or invalidating the cache. The function has to be awaited when the decorator is wrapping an async function.

  Expired items can be removed from the cache with the use of `remove_expired()` function. The function has to be awaited when the decorator is wrapping an async function.

  The original underlying function is accessible through the **wrapped** attribute. This is useful for introspection, bypassing the cache, or for rewrapping the function with a different cache.

  The cache keeps references to the arguments and returns values until they age out of the cache or until the cache is cleared. The cache can be periodically checked for expired items.

  If a method is cached, the self instance argument is included in the cache. If you are caching a method it is strongly recommended to add `__eq__` and `__hash__` methods to the class or set the key parameter.



  The decorator can simply be used without any parameters, both `@alru_cache` and `@alru_cache()` are supported. If you want to modify the caching behavior below you can find the list of parameters that can be set.



  The cache can be enabled or disabled. **It is not checked actively during the runtime!** You cannot update the value once the function is wrapped. If you want to check actively if the cache is enabled use the expiration param.

  ```python
  @alru_cache(enabled=True|False)
  def cache_function(value: str) -> int:
      return len(value)
  ```



  It is possible to override the default cache key generation either with the custom template or with one of the special options. If the custom template is provided the `str.format()` will be used to generate the key. Both the `*args` and `**kwargs` are passed to the `str.format()`. `Kwargs` are extended with the named `args` and the defaults are applied.

  If you want the cache key to always result in the same value the special option `Key.SINGLE_KEY` can be used. This option is only recommended for functions where it is desired to ignore `args` and `kwargs`. The size of this cache will never exceed 1.

  ```python
  from aquiche import alru_cache, Key

  @alru_cache(key="env:{environment.id}:id:{user[id]}")
  async def get_username(environment: object, user: dict) -> str:
      return user["username"]

  @alru_cache(key=Key.SINGLE_KEY)
  async def get_user_count() -> int:
      return 10
  ```



  The maxsize param behaves the same as in `functools.lru_cache`. If set to `None` the cache can grow without bound. If set, the memoizing decorator saves up to the maxsize most recent calls. It is set to `None` by default.

  ```python
  from aquiche import alru_cache

  @alru_cache(maxsize=5)
  async def cache_function_limited(value: str) -> int:
      return len(value)

  @alru_cache(maxsize=None)
  async def cache_function_unlimited(value: str) -> int:
      return len(value)
  ```



  It is possible to set when the function call expires. Expired functions call will automatically be called again the next time the function is being called. To save memory it is possible to set `expired_items_auto_removal_period` to automatically remove items after a certain period of time. If set to `None` expired items are not removed but stay in the cache. It is set to `None` by default. The decorated function still needs to be called for the removal to happen - the expiration removal task is not automatically scheduled. It is recommended to rather use `maxsize` to limit the memory consumption and keep the param set to `None`.

  Possible expiration types/values:

  - `None`, the function call never expires
  - `True|False`, if set to `True` the value is expired and the function will be called again
  - `int|float`, based on the value it will either be treated as the `timedelta` or unix timestamp
  - `datetime`, TTL (Time To Live)/the expiration date, if it contains no timezone the UTC timezone is automatically added
  - `time`, the function call will expire today at this time
  - `timedelta`, TTR (Time To Refresh/refresh interval), the function call will refresh the value each `timedelta` period
  - `datetime|time|timedelta` string, the string that can be parsed to `datetime|time|timedelta`, supported formats: ISO 8601, human-readable formats, uses the same (or nearly the same) resolution as [pydantic](https://pydantic-docs.helpmanual.io)
  - Data pointer string e.g. `$.response.data.expiry`, the pointer can point to any of the other expiration values
  - Function, the `CachedItem` object (for more information see the example below) will be passed as an argument to the function. It is possible to return any of the other expiration types from the function
  - Async function/coroutine, the `CachedItem` object (for more information see the example below) will be passed as an argument to the function. It can only be used when decorating an async function/coroutine. It is possible to return any of the other expiration types from the function

  The expiration types like True, False or datetime are best used in combination with a data pointer or a function/coroutine. It is strongly advised not to set these directly in the decorator.

  The expiration is set to `None` by default.



  ```python
  from aquiche import alru_cache
  from datetime import datetime, timedelta



  @alru_cache(expiration="2012-04-23T09:15:00Z", expired_items_auto_removal_period="1 day")
  async def get_data(value: str) -> int:
      return len(value)


  @alru_cache(
      expiration=datetime(2017, 5, 5, 19, 27, 24),
      expired_items_auto_removal_period="1 hour"
  )
  async def get_data(value: str) -> int:
      return len(value)


  @alru_cache(
      expiration="2012-04-56",
      expired_items_auto_removal_period=timedelta(seconds=300),
  )
  async def get_data(value: str) -> int:
      return len(value)



  @alru_cache(expiration="11:05:00Z", expired_items_auto_removal_period="10 minutes")
  async def get_data(value: str) -> int:
      return len(value)

  """
  Another possible datetime/date/time values:


  '1494012444.883309' -> datetime(2017, 5, 5, 19, 27, 24, 883_309, tzinfo=timezone.utc)
  1_494_012_444.883_309 -> datetime(2017, 5, 5, 19, 27, 24, 883_309, tzinfo=timezone.utc)
  '1494012444' -> datetime(2017, 5, 5, 19, 27, 24, tzinfo=timezone.utc)
  b'1494012444' -> datetime(2017, 5, 5, 19, 27, 24, tzinfo=timezone.utc)
  1_494_012_444 -> datetime(2017, 5, 5, 19, 27, 24, tzinfo=timezone.utc)


  '1494012444000.883309' -> datetime(2017, 5, 5, 19, 27, 24, 883, tzinfo=timezone.utc)
  '-1494012444000.883309' -> datetime(1922, 8, 29, 4, 32, 35, 999117, tzinfo=timezone.utc)
  1_494_012_444_000 -> datetime(2017, 5, 5, 19, 27, 24, tzinfo=timezone.utc)
  '2012-04-23T09:15:00' -> datetime(2012, 4, 23, 9, 15)
  '2012-4-9 4:8:16' -> datetime(2012, 4, 9, 4, 8, 16)
  '2012-04-23T09:15:00Z' -> datetime(2012, 4, 23, 9, 15, 0, 0, timezone.utc)
  '2012-4-9 4:8:16-0320' -> datetime(2012, 4, 9, 4, 8, 16, 0, create_tz(-200))
  '2012-04-23T10:20:30.400+02:30'
      -> datetime(2012, 4, 23, 10, 20, 30, 400_000, create_tz(150))
  '2012-04-23T10:20:30.400+02'
      -> datetime(2012, 4, 23, 10, 20, 30, 400_000, create_tz(120))
  '2012-04-23T10:20:30.400-02'
      -> datetime(2012, 4, 23, 10, 20, 30, 400_000, create_tz(-120))
  b'2012-04-23T10:20:30.400-02'
      -> datetime(2012, 4, 23, 10, 20, 30, 400_000, create_tz(-120))
  datetime(2017, 5, 5) -> datetime(2017, 5, 5)
  0 -> datetime(1970, 1, 1, 0, 0, 0, tzinfo=timezone.utc)

  d1494012444.883309' -> date(2017, 5, 5)
  d'1494012444.883309' -> date(2017, 5, 5)
  d_494_012_444.883_309 -> date(2017, 5, 5)
  d1494012444' -> date(2017, 5, 5)
  d_494_012_444 -> date(2017, 5, 5)
  d -> date(1970, 1, 1)
  d2012-04-23' -> date(2012, 4, 23)
  d'2012-04-23' -> date(2012, 4, 23)
  d2012-4-9' -> date(2012, 4, 9)
  date(2012, 4, 9) -> date(2012, 4, 9)

  '09:15:00' -> time(9, 15)
  '10:10' -> time(10, 10)
  '10:20:30.400' -> time(10, 20, 30, 400_000)
  b'10:20:30.400' -> time(10, 20, 30, 400_000)
  '4:8:16' -> time(4, 8, 16)
  time(4, 8, 16) -> time(4, 8, 16)
  3610 -> time(1, 0, 10)
  3600.5 -> time(1, 0, 0, 500000)
  86400 - 1 -> time(23, 59, 59)
  '11:05:00-05:30' -> time(11, 5, 0, tzinfo=create_tz(-330))
  '11:05:00-0530' -> time(11, 5, 0, tzinfo=create_tz(-330))
  '11:05:00Z' -> time(11, 5, 0, tzinfo=timezone.utc)
  '11:05:00+00' -> time(11, 5, 0, tzinfo=timezone.utc)
  '11:05-06' -> time(11, 5, 0, tzinfo=create_tz(-360))
  '11:05+06' -> time(11, 5, 0, tzinfo=create_tz(360))
  """
  ```



  ```python
  from aquiche import alru_cache
  from datetime import timedelta


  @alru_cache(expiration=timedelta(minutes=10))
  async def cache_function(value: str) -> int:
      return len(value)



  @alru_cache(expiration="1 day 42 minutes 6 seconds")
  async def cache_function(value: str) -> int:
      return len(value)


  @alru_cache(expiration="1m")
  async def cache_function(value: str) -> int:
      return len(value)

  """
  Other possible refresh/timedelta values

  timedelta(seconds=30), timedelta(seconds=30)
  '30' -> timedelta(seconds=30)
  30 -> timedelta(seconds=30)
  30.1 -> timedelta(seconds=30, milliseconds=100)
  9.9e-05 -> timedelta(microseconds=99)

  minutes seconds
  '15:30' -> timedelta(minutes=15, seconds=30)
  '5:30' -> timedelta(minutes=5, seconds=30)

  hours minutes seconds
  '10:15:30' -> timedelta(hours=10, minutes=15, seconds=30)
  '1:15:30' -> timedelta(hours=1, minutes=15, seconds=30)
  '100:200:300' -> timedelta(hours=100, minutes=200, seconds=300)

  days
  '4 15:30' -> timedelta(days=4, minutes=15, seconds=30)
  '4 10:15:30' -> timedelta(days=4, hours=10, minutes=15, seconds=30)

  fractions of seconds
  '15:30.1' -> timedelta(minutes=15, seconds=30, milliseconds=100)
  '15:30.01' -> timedelta(minutes=15, seconds=30, milliseconds=10)
  '15:30.001' -> timedelta(minutes=15, seconds=30, milliseconds=1)
  '15:30.0001' -> timedelta(minutes=15, seconds=30, microseconds=100)
  '15:30.00001' -> timedelta(minutes=15, seconds=30, microseconds=10)
  '15:30.000001' -> timedelta(minutes=15, seconds=30, microseconds=1)
  b'15:30.000001' -> timedelta(minutes=15, seconds=30, microseconds=1)

  iso_8601
  'P4Y', errors.DurationError
  'P4M', errors.DurationError
  'P4W', errors.DurationError
  'P4D' -> timedelta(days=4)
  'P0.5D' -> timedelta(hours=12)
  'PT5H' -> timedelta(hours=5)
  'PT5M' -> timedelta(minutes=5)
  'PT5S' -> timedelta(seconds=5)
  'PT0.000005S' -> timedelta(microseconds=5)
  b'PT0.000005S' -> timedelta(microseconds=5)


  '1m 10h 10s' -> timedelta(seconds=36070)
  '1minute 10hour 10second' -> timedelta(seconds=36070)
  '1minutes 10hours 10seconds' -> timedelta(seconds=36070)
  '1 minutes 2 days 10 hours 10 seconds' -> timedelta(seconds=208870)
  '1 m 2 d 10 h 10 s' -> '1 minute 2 days 10 hours 10 seconds'
      -> timedelta(seconds=208870)
  '1 minute 2 day 10 hours 10 seconds' -> timedelta(seconds=208870)
  """
  ```



  The pointer can point to any expiration value. The data pointer can resolve either dictionaries or objects. If you need more flexibility or you are facing issues with the pointer it is recommended to use function/coroutine expiration. That way you ensure you are returning the right value.

  ```python
  from aquiche import alru_cache
  from typing import Any

  @alru_cache(expiration="$.token.expiration")
  async def cache_function(value: str) -> Any:
      expiry = True

      if value == "user":
          expiry = "30 minutes"
      if value == "service":
          expiry = "12 hours"
      if value == "role":
          expiry = "2022-01-30T00:00:00+0000"

      return {"token": {"expiration": expiry}}
  ```



  It is possible to use both functions and coroutines to set the expiration. If the decorated function is a sync one then it is possible to only use the sync function to set the expiration. `CachedItem` object is passed to the expiration function.

  ```python
  from aquiche import alru_cache, CachedItem

  """
  @dataclass
  class CachedItem:
      value: Any -> the returned value or the raised exception*
      last_fetched: datetime -> when was the value last fetched
      is_error: bool -> set to true if the value contains a raised exception*

  *Only possible when the negative cache is enabled
  """

  async def is_item_expired_async(item: CachedItem) -> bool:
      return item.value > 1

  def is_item_expired(item: CachedItem) -> str | datetime:
      if item.value > 10:
          return "10s"
      if item.value > 5:
          return datetime(2017, 5, 5, 19, 27, 24, tzinfo=timezone.utc)
      return "1 day"



  @alru_cache(expiration=is_item_expired_async)
  async def cache_function_async_1(value: str) -> int:
      return len(value)

  @alru_cache(expiration=is_item_expired)
  async def cache_function_async_2(value: str) -> int:
      return len(value)


  @alru_cache(expiration=is_item_expired)
  def cache_function_sync(value: str) -> int:
      return len(value)





  ```



  The param `wrap_async_exit_stack` simplifies caching of the async clients. When the function is called the returned client(s) (or any other value for that matter) enters the async context. When the client expires or the cache is cleared, the context is automatically cleaned up and renewed if needed. It is recommended to manually clear the cache on the shutdown so the context is closed.

  ```python
  import httpx
  from database_client import DatabaseClient
  from aquiche import alru_cache, await_exit_stack_close_operations, clear_all

  @alru_cache(wrap_async_exit_stack=True)
  async def get_client() -> httpx.AsyncClient:
      return httpx.AsyncClient(base_url="https://api.data.io")


  client = await get_client()

  await client.post("/raspberry_pi")

  await get_client.clear_cache()

  """
  In case of returning multiple clients a list of data pointers can be used to wrap them
  If the data pointer does not point to any value from the result then the error is thrown
  To prevent the error from happening you can append suffix :ignore_missing to the pointer
  """
  @alru_cache(
      wrap_async_exit_stack=["$.clients.database:ignore_missing", "$.clients.http"]
  )
  def get_clients() -> dict:
      return {
          "token": "p@ss123",
          "clients": {
              
              "http": httpx.AsyncClient(),
              "database": DatabaseClient()
          }
      }

  """
  When the cache is cleaned the async context managers will be closed. If you want
  to perform a graceful shutdown you can await the close operations. The command has an
  optional timeout.
  """
  async def shutdown() -> None:
      await clear_all()
      await await_exit_stack_close_operations()

  async def shutdown_timeout() -> None:
      await clear_all()
      await await_exit_stack_close_operations("1minute")
  ```



  It is possible to enable the negative caching. If the negative caching is enabled the errors are not raised but rather cached as if they were the actual results of the function call. The negative cache has a separate expiration which is by default set to 10 seconds. It is recommended to always set the negative cache expiration, preferably to a short duration. The negative caching is disabled by default.

  ```python
  from aquiche import alru_cache


  @alru_cache(negative_cache=True, negative_expiration="30seconds")
  async def cache_function(value: str) -> int | Exception:
      if value == "invalid":
          raise Exception("Invalid data")
      return len(value)

  await cache_function("invalid")
  result = await cache_function("invalid")

  assert isinstance(error, Exception)
  assert str(error) == "Invalid data"
  ```



  The function calls can be retried if they fail. To retry the function call `retry_count` can be set to desired number of retries. The function call is retried with exponential backoff. To set the exponential backoff use the `backoff_in_seconds` param. Both `retry_count` and `backoff_in_seconds` are set to 0 by default.

  ```python
  from aquiche import alru_cache
  import random

  @alru_cache(negative_cache=True, retry_count=3, backoff_in_seconds=2)
  async def cache_function(value: str) -> int | Exception:
      if random.randint(1, 10) > 2:
          raise Exception("Doom has fallen upon us")
      return len(value)
  ```



  The cache can be cleared either individually or all cached functions can be cleared with a clear all function. The contexts are automatically cleaned up on the cache clear if they were created with the use of `wrap_async_exit_stack` param. If you are only using the decorator with the sync functions there is a sync version of the clear all function which only clears the "sync" function caches.

  To remove the expired items `remove_expired()` function can be called.

  ```python
  from aquiche import alru_cache, clear_all, clear_all_sync

  @alru_cache(wrap_async_exit_stack=True)
  async def cache_function_async(value: str) -> Client:
      return Client()

  @alru_cache(retry_count=3, backoff_in_seconds=2)
  def cache_function_sync(value: str) -> int:
      return len(value)


  await cache_function_async.clear_cache()
  cache_function_sync.clear_cache()


  await clear_all()


  clear_all_sync()


  await cache_function_async.remove_expired()
  cache_function_sync.remove_expired()
  ```


pkgId: 1a38203054d0494f27c6517f3a0cc6bc96a06f2d88a0014a26a783202ca052cd
name: python-aquosRemote
arch: src
version: 1.5.1
epoch: 0
release: 1
summary: A small Python module for sending Remote Control Codes to your Sharp AQUOS Smart TV
url: https://github.com/thehappydinoa/aquosRemote
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aquosRemote-1.5.1-1.src.rpm
checksum_type: sha256
description:
  Python module for sending Remote Control Codes to your Sharp AQUOS Smart TV



  ```bash
  pip install aquosRemote
  ```





  1. Go to MENU
  2. Go to the Inital Setup Tab
  3. Go to AQUOS Remote Control
  4. Enable AQUOS Remote



  1. Go to MENU
  2. Go to the Inital Setup Tab
  3. Go to Network Setup
  4. Manual Setup (Click Yes)
  5. Go down to IP Setup



  ```python

  from aquosRemote.aquos import AquosTV


  aquos = AquosTV('IP_ADDRESS')

  aquos.on() # Turns on TV

  aquos.off() # Puts TV into standby mode

  aqous.set_standbymode() # Enables standby mode

  aquos.toggle_power() # Toggle power

  aquos.toggle_power_source() # Toggle power source

  aqous.delay() # Waits a certian time

  aquos.play() # Play button (⏯)

  aquos.pause() # Pause button (⏯)

  aqous.stop() # Stop button

  aquos.rewind() # Rewind button (⏪)

  aqous.fast_forward() # Fast forward button (⏩)

  aquos.rewind() # Skip forward button (⏭)

  aquos.rewind() # Skip back button (⏮)

  aqous.up() # Up button (▲)

  aqous.down() # Down button (▼)

  aqous.left() # Left button (◄)

  aqous.right() # Right button (►)

  aqous.enter() # Enter button

  aqous.remote_return() # Stop button

  aqous.exit() # Exit button

  aqous.volume_up() # Turns volume up

  aqous.volume_down() # Turns volume down

  aquos.volume_repeat(x) # Turns volume up x times up or down

  aquos.set_volume(xx) # Sets TV volume 0-100

  aquos.toggle_mute() # Toggles mute

  aqous.set_mute(boolean) # Sets mute to boolean

  aquos.mute_on() # Turns mute on

  aquos.mute_off() # Turns mute off

  aquos.set_input(x) # Sets TV input to input x

  aquos.toggle_3d() # Toggles 3D

  aquos.netflix() # Opens Netflix

  aquos.smart_central() # Opens Smart Central

  aquos.get_device_name() # Gets TV device name

  aquos.get_model_name() # Gets TV model name

  aquos.get_software_version() # Gets TV software version

  aquos.get_ip_protocol_version() # Gets TV ip protocol

  aquos.get_info() # Returns all above info into a pretty string
  ```

  Note: `aquos.on()` function will work only after you use the setup=True argument or after you turn off tv using this function, then un-plug and re-plug-in the tv.



  [![License](https://img.shields.io/pypi/l/aquosRemote?style=flat-square)](https://github.com/thehappydinoa/aquosRemote/blob/master/LICENSE)


pkgId: 5263e195f770378b938cd77580c59122ee09b92f2b5869b56b8b04f723596fe8
name: python-aqute
arch: src
version: 0.9.2
epoch: 0
release: 1
summary: Async QUeue Task Engine
url: https://github.com/insomnes/aqute
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aqute-0.9.2-1.src.rpm
checksum_type: sha256
description:
  **A**sync **QU**eue **T**ask **E**ngine

  Aqute is a minimalist yet potent Python library specifically designed
  for hassle-free asynchronous task processing. Leveraging the power of async programming,
  Aqute offers:

   - **Efficient Producer-Consumer Model**: Utilizing the Producer-Consumer pattern with
   multiple workers, Aqute ensures streamlined task distribution and swift concurrent processing.
  - **Worker count & Rate Limiting**: Regulate the execution rate of tasks and configure
  the number of workers for concurrent processing, ensuring optimal resource utilization.
  You can use pre-programmed rate limiters or provide your own rate limiting implementation.
  - **Resilient Retry Mechanism**: Tasks that encounter errors can automatically retry,
  with options to specify which error types should trigger retries.
  Exception in handler is returned as error-value.
  - **Versatile task adding**: You can process the whole batch or add tasks on the fly,
  depending on your needs.
  - **Lightweight and simple**: Aqute operates efficiently without relying on any
  external dependencies, ensuring seamless integration and minimal footprint in your projects.

  Aqute simplifies task management in asynchronous landscapes, allowing developers
  to focus on the task logic rather than concurrency challenges.


  - [Install](#install)
  - [Quickstart](#quickstart)
  - [How to use it?](#how-to-use-it)
    - [Simple batch processing](#simple-batch-processing)
    - [Result as async generator per completed](#result-as-async-generator-per-completed)
    - [Infinite loop](#infinite-loop)
    - [Rate limiting](#rate-limiting)
    - [Manual task adding, context manager and error retry](#manual-task-adding-context-manager-and-error-retry)
    - [Manual flow management and custom result queue](#manual-flow-management-and-custom-result-queue)
    - [Even more manual management and internal worker queue size](#even-more-manual-management-and-internal-worker-queue-size)
    - [Use priroty queue](#use-priroty-queue)
    - [Task timeout setting](#task-timeout-setting)
    - [Early stopping on too many failed tasks](#early-stopping-on-too-many-failed-tasks)
    - [Barebone queue via Foreman](#barebone-queue-via-foreman)
  - [Some caveats](#some-caveats)
    - [Start load timeout](#start-load-timeout)
    - [You can't wait on not started Aqute](#you-can-t-wait-on-not-started-aqute)
  - [Misc](#misc)
    - [Instance reuse after stop()](#instance-reuse-after-stop)
    - [Type checking and generics](#type-checking-and-generics)


  Python 3.9+ required:
  ```bash
  pip install aqute
  ```


  Apply your async function to each item of some iterable and get list of wrapped in
  `AquteTask` results, ordered the same way:

  ```python
  import asyncio
  from aqute import Aqute

  async def main():
      async def handler(i: int) -> int:
          await asyncio.sleep(i / 20)
          return i * 2

      aqute = Aqute(handle_coro=handler, workers_count=2)
      result = await aqute.apply_to_all(range(10))
      
      assert [t.result for t in result] == [i * 2 for i in range(10)]

  asyncio.run(main())
  ```


  While a deep dive is available through Aqute's method docstrings, it's not necessary.

  Aqute is easy to use for both simple and advanced workflows.


  The easiest way to use Aqute is `apply_to_all()` method:

  ```python
  import asyncio
  import logging
  from random import randint, random

  from aqute import Aqute, AquteError


  logging.basicConfig(level=logging.INFO, format='s - s - s - s')

  logger = logging.getLogger("main")

  async def handler(i: int) -> str:
      """
      NOTE: This is a mock handler for demonstration purposes.
      Replace the logic below with your own specific task processing logic.
      """
      await asyncio.sleep(0.01 + (0.09) * random())

      
      if i >= 19:
          raise KeyError(f"The Key for {i}")

      
      r = randint(1, 101)
      if r >= 80:
          raise ValueError(f"Got big number for {i}")

      return f"success {i}"

  async def main():
      
      input_data = list(range(20))

      
      
      aqute = Aqute(handle_coro=handler, workers_count=10, retry_count=2)
      result = await aqute.apply_to_all(input_data)
      
      assert [t.data for t in result] == input_data

      ...


  asyncio.run(main())

  ```


  ```python
      
      
      input_data = list(range(20))
      aqute = Aqute(handle_coro=handler, workers_count=10)

      done, with_errors = [], []
      
      async for task in aqute.apply_to_each(input_data):
          if task.success:
              done.append(task)
          else:
              with_errors.append(task)

      assert len(done + with_errors) == len(input_data)

  ```


  You can run aqute on "infinite" amount of tasks if needed and control "end"
  from outside. Outside of context or with `stop()` coro it will shutdown gracefully.

  ```python
  import asyncio
  import logging
  from random import random

  from aqute import Aqute


  logging.basicConfig(level=logging.INFO, format='s - s - s - s')

  logger = logging.getLogger("main")

  async def handler(i: int) -> str:
      """
      NOTE: This is a mock handler for demonstration purposes.
      """
      await asyncio.sleep(0.01 + (0.009) * random())

      return f"success {i}"

  async def main():
      """
      This example shows "infinite"workflow for aqute.
      Here limited by 10_000 tasks, but it can be without any end.
      """

      
      TASK_LIMIT = 10_000
      done = asyncio.Event()

      aqute = Aqute(handle_coro=handler, workers_count=20)

      async def add_tasks():
          
          for i in range(TASK_LIMIT):
              await aqute.add_task(i)
              
              await asyncio.sleep(0.01 + (0.009) * random())

      result = []

      async def collect_results():
          
          while len(result) < TASK_LIMIT:
              task = await aqute.get_task_result()
              result.append(task)
          done.set()

      async with aqute:
          asyncio.create_task(add_tasks())
          asyncio.create_task(collect_results())
          
          
          while not done.is_set():
              logger.info(f"Done tasks: {len(result):_}/{TASK_LIMIT:_}")
              await asyncio.sleep(5)

      logger.info(f"Done tasks: {len(result):_}/{TASK_LIMIT:_}")


  asyncio.run(main())
  ```


  You can also add RateLimiter instance to Aqute for rate limiting:
  ```python

      from aqute.ratelimiter import TokenBucketRateLimiter

      
      input_data = list(range(20))
      r_limit = TokenBucketRateLimiter(5, 1)
      aqute = Aqute(handle_coro=handler, workers_count=10, rate_limiter=r_limit)
      result = []
      async for task in aqute.apply_to_each(input_data):
          result.append(task)

      assert len(result) == len(input_data)
  ```

  There are three available `RateLimiter` implementations:
  - `TokenBucketRateLimiter`: steady rate by default, burstable with `allow_burst` option;
  - `SlidingRateLimiter`: next call will be available after enough time from the oldest one;
  - `PerWorkerRateLimiter`: enforces separate rate limits for each unique worker with separate `TokenBucketRateLimiter` instances;
  - `RandomizedIntervalRateLimiter`: introduces more random intervals between each call,
  but enforcing `max_rate` over `time_period` limit.

  You can write your own `RateLimiter` implementation with specific algorithm if needed.


  This can be most useful if not all of your tasks are available at the start:
  ```python
      
      
      
      
      
      aqute = Aqute(
          handle_coro=handler,
          workers_count=10,
          
          retry_count=5,
          
          specific_errors_to_retry=(ValueError,),
          
          errors_to_not_retry=(ValueError,),
      )
      for i in range(10):
          
          await aqute.add_task(i, task_id=f"My task id: {i}")


      async with aqute:
          await asyncio.sleep(0.1)
          for i in range(10, 15):
              await aqute.add_task(i, task_id=f"My task id: {i}")

          await asyncio.sleep(0.1)
          for i in range(15, 20):
              await aqute.add_task(i, task_id=f"My task id: {i}")

          
          await aqute.wait_till_end()

      
      
      for tr in aqute.extract_all_results():
          logger.info(f"{tr.success, tr.error, tr.result}")
  ```


  ```python
      
      
      result_q = asyncio.Queue(5)

      aqute = Aqute(handle_coro=handler, workers_count=10, result_queue=result_q)
      for i in range(10):
          
          asyncio.create_task(aqute.add_task(i))
      await asyncio.sleep(0.1)

      
      aqute.start()
      
      await asyncio.sleep(1)

      
      assert result_q.qsize() == 5
      for _ in range(5):
          await result_q.get()

      
      
      await aqute.wait_till_end()
      assert result_q.qsize() == 5
      
      await aqute.stop()
  ```


  ```python
      
      aqute = Aqute(
          handle_coro=handler, workers_count=10, input_task_queue_size=2
      )
      for i in range(10):
          await aqute.add_task(i)
      
      aqute.set_all_tasks_added()

      aqute_run_aiotask = aqute.start()
      await aqute_run_aiotask
      await aqute.stop()

      assert aqute.result_queue.qsize() == 10
  ```


  You can prioritize tasks by setting `use_priority_queue` flag:

  ```python
      async def handler(i: int) -> int:
          return i

      
      aqute = Aqute(
          workers_count=1,
          handle_coro=handler,
          use_priority_queue=True,
      )
      await aqute.add_task(1_000_000)
      await aqute.add_task(10, task_priority=10)
      await aqute.add_task(5, task_priority=5)
      await aqute.add_task(10, task_priority=10)
      await aqute.add_task(1, task_priority=1)

      async with aqute:
          await aqute.wait_till_end()

      results = aqute.extract_all_results()
      assert [t.data for t in results] == [1, 5, 10, 10, 1_000_000]
  ```


  The `task_timeout_seconds` option is used to specify a time limit for each task.
  If a task exceeds this duration, it is considered a timeout and is
  handled according to the specified retry logic.


  By default setting timeout will result in task timeout if task exceeds value, but
  retry logic is applied if `retry_count > 0`.

  ```python
  aqute = Aqute(
      handle_coro=your_handler_coroutine,
      task_timeout_seconds=5,
      retry_count=2,
      
  )
  ```


  To disable this behavior you can set `errors_to_not_retry` with `AquteTaskTimeoutError`:
  ```python
  aqute = Aqute(
      handle_coro=your_handler_coroutine,
      task_timeout_seconds=5,
      retry_count=2,
      errors_to_not_retry=AquteTaskTimeoutError,
      
  )
  ```


  If you want to stop the processing when too many tasks have failed, you can use the
  `total_failed_tasks_limit` option. This will raise `AquteTooManyTasksFailedError` if
  the limit is reached before all tasks are processed:
  ```python
  async def failing_handler(task: int) -> int:
      await asyncio.sleep(0.01)
      if task % 2 == 0:
          raise ValueError("Even task number")
      return task

  aqute = Aqute(
      workers_count=2,
      handle_coro=failing_handler,
      total_failed_tasks_limit=5,
  )
  for i in range(10):
      await aqute.add_task(i)



  async with aqute:
      await aqute.wait_till_end()
  ```


  If you don't need retry flow and high-level helpers you can use `Foreman` for bare flow,
  but still with rate limiting support:
  ```python
  import asyncio
  from random import random

  from aqute.worker import Foreman
  from aqute.ratelimiter import TokenBucketRateLimiter

  async def handler(i: int) -> str:
      await asyncio.sleep(0.01 + (0.09) * random())
      return f"Success {i}"

  async def main():
      
      foreman = Foreman(
          handle_coro=handler,
          workers_count=10,
          rate_limiter=TokenBucketRateLimiter(5, 1),
          input_task_queue_size=100,
      )
      for i in range(20):
          await foreman.add_task(AquteTask(i, f"{i}"))

      foreman.start()

      result = []
      for _ in range(20):
          
          
          r = await foreman.get_handled_task()
          assert r.error is None
          logger.info(r.result)
          result.append(r)

      
      await foreman.finalize()
  ```




  If no tasks will be provided, and you've set the timeout, Aqute will intentionally fail:
  ```python
      try:
          async with Aqute(
              handle_coro=handler,
              workers_count=10,
              start_timeout_seconds=1,
          ) as aqute:
              await asyncio.sleep(1.2)
      except AquteError as exc:
          logger.error(f"Aqute timeouted: {exc}")
  ```


  ```python
      
      aqute = Aqute(handle_coro=handler, workers_count=10)

      try:
          await aqute.wait_till_end()
      except AquteError as exc:
          logger.error(f"Aqute cannot be waited here: {exc}")
  ```



  ```python
      
      aqute = Aqute(handle_coro=handler,workers_count=5)
      async with aqute:
          for i in range(10):
              await aqute.add_task(i)
          await aqute.wait_till_end()

      async with aqute:
          for i in range(10, 20):
              await aqute.add_task(i)
          await aqute.wait_till_end()

      assert aqute.result_queue.qsize() == 20
  ```


  You should get error during type check if you would try to use wrong type with
  `Aqute` methods (types are indered based on your provided handler):
  ```python
  from aqute import Aqute

  async def handler(i: int) -> str:
      return f"success {i}"


  async def main() -> None:
      aqute = Aqute(
          handle_coro=handler,
          workers_count=10
      )
      
      await aqute.add_task("10")
  ```

  You can also provide the expected types of in/out via generics mechanism:
  ```python
  from aqute import Aqute

  async def handler(i: int) -> str:
      return f"success {i}"


  async def main() -> None:
      
      aqute = Aqute[int, int](
          handle_coro=handler,
          workers_count=10
      )

      await aqute.add_task(123)
  ```


pkgId: 10e0908317f01892d6f6fbd1f7e5f956527cf1e591524b7f3e3a26f4a7910c63
name: python-ar
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Access ar archive files (.a)!
url: https://pypi.org/project/ar/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ar-1.0.0-1.src.rpm
checksum_type: sha256
description:
  ![build](https://github.com/vidstige/ar/actions/workflows/python-package.yml/badge.svg)

  ![python-3.11](https://img.shields.io/badge/python-3.11-success)
  ![python-3.10](https://img.shields.io/badge/python-3.10-success)
  ![python-3.9](https://img.shields.io/badge/python-3.9-success)
  ![python-3.8](https://img.shields.io/badge/python-3.8-success)
  ![python-3.7](https://img.shields.io/badge/python-3.7-success)



  Python package for parsing ar archive file.


  `pip install ar`


  List files inside `file.a`
  ```python
  from ar import Archive
  with open('file.a', 'rb') as f:
    archive = Archive(f)
    for entry in archive:
      print(entry.name)
  ```

  Read content of `file.txt` contained within `file.a`.

  ```python
  from ar import Archive
  with open('file.a', 'rb') as f:
    archive = Archive(f)
    print(archive.open('file.txt').read())
  ```

  Extract all files:
  ```python
  from ar import Archive
  with open('file.a', 'rb') as f:
    archive = Archive(f)
    for entry in archive:
      with open(entry.name, 'wb') as output:
        content = archive.open(entry, 'rb').read()
        output.write(content)
  ```


  Create a virtual environment using python version of liking

      python3.10 -m venv venv

  Activate it

      source venv/bin/activate

  Install package editable together with relevant optional dependencies

      pip install -e '.[test,dev]'


  Samuel Carlsson


pkgId: 9de91256264d63d880be2adab830ef11d51cece9a7a8d322b4fe2b09a1d7f60b
name: python-ar-corrector
arch: src
version: 1.1.6
epoch: 0
release: 1
summary: Arabic Spelling Correction
url: https://pypi.org/project/ar-corrector/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ar-corrector-1.1.6-1.src.rpm
checksum_type: sha256
description:
  Simple library to check the spelling of arabic sentences. This library uses a vocabulary that consists of +500K words, and uses 1-edit_distance and 2-edit_distance to correct the misspelled words. It also uses 1-ngram language model to correct the words depending on the previous context.

  ```
  pip install ar-corrector
  ```


  ```python
  from ar_corrector.corrector import Corrector
  corr = Corrector()

  corr.spell_correct('بختب') # return 5 corrections with top frequencies


  corr.spell_correct('بختب', 2) # return 2 corrections with top frequencies


  corr.spell_correct('بختب', 1) # return 1 correction with top frequency


  corr.spell_correct('لتمشتلميتلكب', 4) # return the same word


  corr.spell_correct('من') # return true

  ```

  ```python
  from ar_corrector.corrector import Corrector
  corr = Corrector()

  sent = 'أكدت قواءص التمذد في تشاد أنها تواضضل طريقها للعاحمة'
  print(corr.contextual_correct(sent))


  sent = 'اتتنتهى حدث آبل المنتظو بالإعلاخ عن مموعة من المنتجات'
  print(corr.contextual_correct(sent))

  ```


pkgId: 4681babbb0a8e1635c94f68055a1eb5e67ec675986478107a2d9177956e35b45
name: python-ara
arch: src
version: 1.7.2
epoch: 0
release: 1
summary: ARA Records Ansible
url: https://github.com/ansible-community/ara
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ara-1.7.2-1.src.rpm
checksum_type: sha256
description:
  ARA Records Ansible and makes it easier to understand and troubleshoot.

  ![logo](doc/source/_static/ara-with-icon.png)

  It is another recursive acronym with a focus on simplicity.



  ara provides Ansible reporting by recording ``ansible`` and ``ansible-playbook`` commands regardless of how and where they run:

  - from most Linux distributions and even on Mac OS (as long as ``python >= 3.8`` is available)
  - from tools that run Ansible like ansible-(pull|test|runner|navigator), AWX & Automation Controller (Tower), Molecule and Semaphore
  - from a terminal, a script or by hand
  - from a laptop, desktop, server, virtual machine, container or execution environment
  - from CI/CD platforms such as Jenkins, Rundeck and Zuul
  - from git forges like GitHub, GitLab, Gitea & Forgejo

  The recorded results are available via an included CLI, a REST API as well as a self-hosted, local-first web reporting interface.

  <!-- https://github.com/ansible-community/ara/blob/master/doc/source/_static/demo.mp4 -->
  https://github.com/ansible-community/ara/assets/1291204/4fbdf5f7-509c-46ea-beb0-726b43e1b985



  ARA Records Ansible results to SQLite, MySQL and PostgreSQL databases with a standard [callback plugin](https://docs.ansible.com/ansible/latest/plugins/callback.html).

  This plugin gathers data as Ansible runs and sends it to a Django REST API server:

  ![recording-workflow](doc/source/_static/graphs/recording-workflow.png)



  - Any recent Linux distribution or Mac OS with python >=3.8 available
  - The ara package (containing the Ansible plugins) must be installed for the same python interpreter as Ansible itself



  For production use, consider learning about [best practices](https://ara.readthedocs.io/en/latest/troubleshooting.html#improving-playbook-recording-performance), [enabling authentication](https://ara.readthedocs.io/en/latest/api-security.html#authentication) and [ignoring what doesn't need to be recorded](https://ara.readthedocs.io/en/latest/ansible-plugins-and-use-cases.html#ansible-plugins).



  ara records to a local sqlite database by default and does not require a persistent server:

  ```bash

  python3 -m pip install --user ansible "ara[server]"


  export ANSIBLE_CALLBACK_PLUGINS="$(python3 -m ara.setup.callback_plugins)"


  ansible-playbook playbook.yml


  ara playbook list
  ara host list


  ara-manage runserver
  ```

  ![getting-started](doc/source/_static/getting-started.gif)



  The server includes a REST API as well a web reporting interface.

  Consider running one to aggregate playbook runs from different tools, jobs or servers into a single dashboard that can be shared with friends.

  Get started with the [ara_api role](https://github.com/ansible-community/ara-collection/blob/master/roles/ara_api/README.md)
  or with the [container images](https://ara.readthedocs.io/en/latest/container-images.html) published by the project on
  [DockerHub](https://hub.docker.com/r/recordsansible/ara-api) and [quay.io](https://quay.io/repository/recordsansible/ara-api):

  ```bash

  mkdir -p ~/.ara/server


  docker run --name api-server --detach --tty \
    --volume ~/.ara/server:/opt/ara -p 8000:8000 \
    docker.io/recordsansible/ara-api:latest


  podman run --name api-server --detach --tty \
    --volume ~/.ara/server:/opt/ara -p 8000:8000 \
    quay.io/recordsansible/ara-api:latest
  ```

  Once the server is running, ara must be installed and configured to send data to it:

  ```bash

  python3 -m pip install --user ansible ara


  export ANSIBLE_CALLBACK_PLUGINS="$(python3 -m ara.setup.callback_plugins)"


  export ARA_API_CLIENT="http"
  export ARA_API_SERVER="http://127.0.0.1:8000"


  ansible-playbook playbook.yml


  ara playbook list
  ara host list


  ```



  A live demo is deployed with the ara Ansible collection from [Ansible Galaxy](https://galaxy.ansible.com/recordsansible/ara).

  It is available at https://demo.recordsansible.org.



  Documentation for installing, configuring, running and using ara is available on [ara.readthedocs.io](https://ara.readthedocs.io).

  Common issues may be resolved by reading the [troubleshooting guide](https://ara.readthedocs.io/en/latest/troubleshooting.html).

  Changelog and release notes are available within the repository's [git tags](https://github.com/ansible-community/ara/tags) as well as the [documentation](https://ara.readthedocs.io/en/latest/changelog-release-notes.html).



  - Bugs, issues and enhancements: https://github.com/ansible-community/ara/issues
  - IRC: #ara on [Libera.chat](https://web.libera.chat/?channels=#ara)
  - Matrix: Bridged from IRC via [#ara:libera.chat](https://matrix.to/#/#ara:libera.chat)
  - Slack: Bridged from IRC via [https://arecordsansible.slack.com](https://join.slack.com/t/arecordsansible/shared_invite/enQtMjMxNzI4ODAxMDQxLTU2NTU3YjMwYzRlYmRkZTVjZTFiOWIxNjE5NGRhMDQ3ZTgzZmQyZTY2NzY5YmZmNDA5ZWY4YTY1Y2Y1ODBmNzc>)
  - Website and blog: https://ara.recordsansible.org
  - ~~Twitter: https://twitter.com/recordsansible~~
  - Mastodon: https://fosstodon.org/@ara



  Contributions to the project are welcome and appreciated !

  Get started with the [contributor's documentation](https://ara.readthedocs.io/en/latest/contributing.html).



  Code contributions to the project can be viewed from the git log or on [GitHub](https://github.com/ansible-community/ara/graphs/contributors).

  The ara parrot logo was designed and contributed by [Jason E. Rist](https://github.com/ansible-community/ara/commit/0d5d0939a6b7a319d99acc1fb20d4ca282bd76ab).



  ```
  Copyright (c) 2023 The ARA Records Ansible authors

  ARA Records Ansible is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  ARA Records Ansible is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with ARA Records Ansible.  If not, see <http://www.gnu.org/licenses/>.
  ```


pkgId: a6babd10255a70155e333e6f977323f08e122f86f972a0929b7a0641d8af2e81
name: python-araali
arch: src
version: 0.0.36
epoch: 0
release: 1
summary: Araali API
url: https://github.com/araalinetworks/api/tree/main/python/api
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-araali-0.0.36-1.src.rpm
checksum_type: sha256
description:
  This is a python library to expose access to Araali APIs


  ```

  cd ~/
  python3 -m venv araaliapienv
  source araaliapienv/bin/activate
  pip install araali


  cd ~/
  source araaliapienv/bin/activate
  pip install --upgrade araali


  export ARAALI_API_TOKEN="<your-token-here>"


  python -m pydoc araali
  python -m araali -h


  >>> import araali
  >>> help(araali)
  ```

rpm_license:
  MIT License  Copyright (c) 2021 araalinetworks  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: b2b082cee5ebb39fec61c3627baf42389f51a50f327b351b7933b3f03c960e64
name: python-arabert
arch: src
version: 1.0.1
epoch: 0
release: 1
url: https://github.com/aub-mind/arabert
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arabert-1.0.1-1.src.rpm
checksum_type: sha256
summary:
  AraBERT is a Python library that contains thecode for the AraBERT, AraGPT2 and AraELECTRA models withthe preprocessing scripts.

description:
  AraBERTv0.2-Twitter-base| [bert-base-arabertv02-twitter](https://huggingface.co/aubmindlab/bert-base-arabertv02-twitter) | 543MB / 136M | No | Same as v02 + 60M Multi-Dialect Tweets|
  AraBERTv0.2-Twitter-large| [bert-large-arabertv02-twitter](https://huggingface.co/aubmindlab/bert-large-arabertv02-twitter) | 1.38G / 371M | No | Same as v02 + 60M Multi-Dialect Tweets|
  AraBERTv0.2-base | [bert-base-arabertv02](https://huggingface.co/aubmindlab/bert-base-arabertv02) | 543MB / 136M | No | 200M / 77GB / 8.6B |
   AraBERTv0.2-large| [bert-large-arabertv02](https://huggingface.co/aubmindlab/bert-large-arabertv02) | 1.38G / 371M | No | 200M / 77GB / 8.6B |
  AraBERTv2-base| [bert-base-arabertv2](https://huggingface.co/aubmindlab/bert-base-arabertv2) | 543MB / 136M | Yes | 200M / 77GB / 8.6B |
  AraBERTv2-large| [bert-large-arabertv2](https://huggingface.co/aubmindlab/bert-large-arabertv2) | 1.38G / 371M | Yes | 200M / 77GB / 8.6B |
   AraBERTv0.1-base| [bert-base-arabertv01](https://huggingface.co/aubmindlab/bert-base-arabertv01) | 543MB / 136M | No | 77M / 23GB / 2.7B |
  AraBERTv1-base| [bert-base-arabert](https://huggingface.co/aubmindlab/bert-base-arabert) | 543MB / 136M | Yes | 77M / 23GB / 2.7B |
  All models are available in the `HuggingFace` model page under the [aubmindlab](https://huggingface.co/aubmindlab/) name. Checkpoints are available in PyTorch, TF2 and TF1 formats.

  We identified an issue with AraBERTv1's wordpiece vocabulary. The issue came from punctuations and numbers that were still attached to words when we trained the wordpiece vocab. We now insert a space between numbers and characters and around punctuation characters.
  The new vocabulary was learnt using the `BertWordpieceTokenizer` from the `tokenizers` library, and now supports the Fast tokenizer implementation from the `transformers` library.
  **P.S.**: All the old BERT codes should work with the new BERT, just change the model name and check the new preprocessing function
  **Please read the section on how to use the https://github.com/aub-mind/arabert#preprocessing**

  We used ~3.5 times more data, and trained for longer.
  For Dataset Sources see the https://github.com/aub-mind/arabert#Dataset


pkgId: edc4e457e9889ffea4af965bfe1c3be72227c54a185a20c4915d45a824822dee
name: python-arabic-reshaper
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Reconstruct Arabic sentences to be used in applications that do not support Arabic
url: https://github.com/mpcabd/python-arabic-reshaper/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arabic-reshaper-3.0.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://app.travis-ci.com/mpcabd/python-arabic-reshaper.svg?branch=master)](https://app.travis-ci.com/mpcabd/python-arabic-reshaper)

  Reconstruct Arabic sentences to be used in applications that don't support
  Arabic script.

  Works with Python 3.x



  Arabic script is very special with two essential features:

  1. It is written from right to left.
  2. The characters change shape according to their surrounding characters.

  So when you try to print text written in Arabic script in an application
  – or a library – that doesn’t support Arabic you’re pretty likely to end up
  with something that looks like this:

  ![Arabic text written from left to right with no reshaping](http://mpcabd.xyz/wp-content/uploads/2012/05/arabic-1.png)

  We have two problems here, first, the characters are in the isolated form,
  which means that every character is rendered regardless of its surroundings,
  and second is that the text is written from left to right.

  To solve the latter issue all we have to do is to use the
  [Unicode bidirectional algorithm](http://unicode.org/reports/tr9/), which is
  implemented purely in Python in
  [python-bidi](https://github.com/MeirKriheli/python-bidi).
  If you use it you’ll end up with something that looks like this:

  ![Arabic text written from right to left with no reshaping](http://mpcabd.xyz/wp-content/uploads/2012/05/arabic-6.png)

  The only issue left to solve is to reshape those characters and replace them
  with their correct shapes according to their surroundings. Using this library
  helps with the reshaping so we can get the proper result like this:

  ![Arabic text written from right to left with reshaping](http://mpcabd.xyz/wp-content/uploads/2012/05/arabic-3.png)



      pip install --upgrade arabic-reshaper

  If you're using Anaconda you can use

      conda install -c mpcabd arabic-reshaper



  ```python
  import arabic_reshaper

  text_to_be_reshaped = 'اللغة العربية رائعة'
  reshaped_text = arabic_reshaper.reshape(text_to_be_reshaped)
  ```



  PIL Image does not support reshaping out of the box, so to draw Arabic text on an `Image` instance you would need to reshape
  the text for sure.

  For this example to work you need to run `pip install --upgrade arabic-reshaper python-bidi pillow`

  ```python

  import arabic_reshaper

  text_to_be_reshaped = 'اللغة العربية رائعة'
  reshaped_text = arabic_reshaper.reshape(text_to_be_reshaped)








  from bidi.algorithm import get_display
  bidi_text = get_display(reshaped_text)






  from PIL import Image, ImageDraw, ImageFont


  font = ImageFont.truetype('Arial', 40)

  image = Image.new('RGBA', (800, 600), (255,255,255,0))
  image_draw = ImageDraw.Draw(image)
  image_draw.text((10,10), bidi_text, fill=(255,255,255,128), font=font)


  image.show()




  ```



  You can configure the reshaper to your preferences, it has the following
  settings defined:

  * `language` (Default: `'Arabic'`): Ignored, the reshaper works with Arabic,
  Farsi, and Urdu, and most probably all other languages that use Arabic script.
  * `support_ligatures` (Default: `True`): When this is set to `False`, the
  reshaper will not replace any ligatures, otherwise it will replace enabled
  ligatures.
  * `delete_harakat` (Default: `True`): When this is set to `False` the reshaper
  will not delete the harakat from the text, this will result in them showing up
  in the reshaped text, you should enable this option if you are going to pass
  the reshaped text to `bidi.algorithm.get_display` because it will reverse the
  text and you'd end up with harakat applied to the next letter instead of the
  previous letter.
  * `delete_tatweel` (Default `False`): When this is set to `True` the reshaper
  will delete the Tatweel character (U+0640) from the text before reshaping, this
  can be useful when you want to support ligatures and don't care about Tatweel
  getting deleted.
  * `shift_harakat_position` (Default `False`): Whether to shift the Harakat
  (Tashkeel) one position so they appear correctly when string is reversed, this
  might solve the problem of Tashkeel in some systems, although for `PIL.Image`
  for example, this is not needed.
  * `support_zwj` (Default `True`): Whether to support ZWJ (`U+200D`) or not.
  * `use_unshaped_instead_of_isolated` (Default `False`): Use unshaped form
  instead of isolated form, useful in some fonts that are missing the isolated
  form of letters.

  Besides the settings above, you can enable/disable supported ligatures. For a
  full list of supported ligatures and their default status check the file
  [default-config.ini](https://github.com/mpcabd/python-arabic-reshaper/blob/32f7497aa24a68ab880d0248b21715928f0ce212/arabic_reshaper/default-config.ini).

  There are multiple ways that you can configure the reshaper in, choose the one
  that suits your deployment:



  Instead of directly using `arabic_reshaper.reshape` function, define an
  instance of `arabic_reshaper.ArabicReshaper`, and pass your config dictionary
  to its constructor's `configuration` parameter like this:

  ```python
  from arabic_reshaper import ArabicReshaper
  configuration = {
      'delete_harakat': False,
      'support_ligatures': True,
      'RIAL SIGN': True,  # Replace ر ي ا ل with ﷼
  }
  reshaper = ArabicReshaper(configuration=configuration)
  text_to_be_reshaped = 'سعر المنتج ١٥٠ ر' + 'يال'  # had to split the string for display
  reshaped_text = reshaper.reshape(text_to_be_reshaped)
  ```



  You can separte the configuration from your code, by copying the file
  [default-config.ini](default-config.ini) and change its settings,
  then save it somewhere in your project, and then you can tell the reshaper
  to use your new config file, just pass the path to your config file to its
  constructor's `configuration_file` parameter like this:

  ```python
  from arabic_reshaper import ArabicReshaper
  reshaper = ArabicReshaper(configuration_file='/path/to/your/config.ini')
  text_to_be_reshaped = 'سعر المنتج ١٥٠ ر' + 'يال'  # had to split the string for display
  reshaped_text = reshaper.reshape(text_to_be_reshaped)
  ```

  Where in you `config.ini` you can have something like this:

  ```
  [ArabicReshaper]
  delete_harakat = no
  support_ligatures = yes
  RIAL SIGN = yes
  ```



  Instead of having to rewrite your old code to configure it like above, you can
  define an environment variable with the name
  `PYTHON_ARABIC_RESHAPER_CONFIGURATION_FILE` and in its value put the full path
  to the configuration file. This way the reshape function will pick it
  automatically, and you won't have to change your old code.



  If you intend to render the text in a TrueType® font, you can tell the library
  to generate its configuration by reading the font file to figure out what's
  supported in the font and what's not.

  To use this feature you need to install the library with an extra option
  (not necessary when you install it with conda):

      pip install --upgrade arabic-reshaper[with-fonttools]

  Then you can use the reshaper like this:

  ```python
  import arabic_reshaper

  reshaper = arabic_reshaper.ArabicReshaper(
      arabic_reshaper.config_for_true_type_font(
          '/path/to/true-type-font.ttf',
          arabic_reshaper.ENABLE_ALL_LIGATURES
      )
  )
  ```

  This will parse the font file, and figure out what ligatures it supports and enable them,
  as well as whether it has isolated forms or `use_unshaped_instead_of_isolated` should be
  enabled.

  The second parameter to `config_for_true_type_font` can be one of

  - `ENABLE_NO_LIGATURES`
  - `ENABLE_SENTENCES_LIGATURES`
  - `ENABLE_WORDS_LIGATURES`
  - `ENABLE_LETTERS_LIGATURES`
  - `ENABLE_ALL_LIGATURES` (default)

  which controls what ligatures to look for, depending on your usage,
  see [default-config.ini](default-config.ini) to know what ligatures are there.



  [Harakat or Tashkeel](http://en.wikipedia.org/wiki/Arabic_diacritics#Tashkil_.28marks_used_as_phonetic_guides.29)
  might not show up properly in their correct place, depending on the application
  or the library that is doing the rendering for you, so you might want to enable
  the `shift_harakat_position` option if you face this problem.



  This work is licensed under
  [MIT License](https://opensource.org/licenses/MIT).



  Online Arabic Reshaper: http://pydj.mpcabd.xyz/arabic-reshaper/



  https://github.com/mpcabd/python-arabic-reshaper/tarball/master




  * Stop supporting Python 2.7
  * Remove dependency on `future`. See #88.



  * Fix unparseable version bound for `fonttools` under Python 2



  * Remove dependency on `__version__.py` and `default-config.ini` files, as they were causing problems for people who package their apps using pyinstaller or buildozer.



  * Fix a warning. See #57. Thanks @fbernhart



  * Added support for settings based on a TrueType® font



  * New option `use_unshaped_instead_of_isolated` to get around some fonts missing the isolated form for letters.



  **BROKEN** please make sure not to use this version.



  * Updated letters and ligatures
  * New option `shift_harakat_position` to try to get around the Tashkeel problem



  * Proper support for ZWJ



  * Fix Shadda ligatures



  * Added support for ZWJ (Zero-width Joiner) (U+200D)



  * Added `delete_tatweel`
  * Added more test cases



  * Fix tests for Python 2.7



  * Fixed a bug with Harakat breaking the reshaping
  * Wrote two small unit tests, more to come
  * Moved letters and ligatures to separate files for readability/maintainability
  * Moved package to its own folder for readability/maintainability



  Fix error message formatting



  Fix error message formatting



  Use `Exception` instead of `Error`.



  Use `pkg_resources.resource_filename` instead of depending on `__file__` to access `default-config.ini`.



  Include default-config.ini in setup.py



  * Totally rewrote the code;
  * Faster and better performance;
  * Added the ability to configure and customise the reshaper.



  * New glyphs for Farsi;
  * Added setup.py;
  * Bugfixes.



  * Ported [Better Arabic Reshaper](https://github.com/agawish/Better-Arabic-Reshaper/)
  to Python.



  Abdullah Diab (mpcabd)
  Email:  mpcabd@gmail.com
  Blog:   http://mpcabd.xyz

  For more info visit my blog
  [post here](http://mpcabd.xyz/python-arabic-text-reshaper/)


pkgId: 77833bf6c240067ae5ce30f68c1f072fa29c0c24fb5b5a37d43b6759b8217bb7
name: python-arachnid-spider
arch: src
version: 0.9.5.1
epoch: 0
release: 1
summary: An OSINT tool to find data leaks on a targeted domain
url: https://github.com/jake-bickle/Arachnid
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arachnid-spider-0.9.5.1-1.src.rpm
checksum_type: sha256
description:
  Arachnid is an OSINT web crawler that targets a website, attempts to enumerate all of the pages within it, and then search for interesting or sensitive information both defined by the tool and/or the user. Arachnid is built in Python, and the data is visualized via a php web app.

  ![Scan Dashboard](https://github.com/jake-bickle/Arachnid/blob/master/scan_dashboard_feature.png)


  Arachnid started with a simple question: “is there a way that users could find all the emails of a supplied domain to help with OSINT efforts?” This of course could only be answered by using a web crawler to visit and search every page in a given domain. But then followup questions arose: “if we are already visiting each page and looking for emails, couldn’t we look for other interesting information as well?” And thus, the idea for a fully developed OSINT web crawler was born.  Presently, the default scan for Arachnid searches for the following information:

  * Email addresses
  * Phone numbers
  * Common documents and files
  * Social Media Handles
  * User supplied strings and regex (optional)

  To help support scanning efforts, Arachnid also comes with some other features such as:

  * The ability to choose a given user agent to make the scan requests
  * The ability to add a delay to the scan requests as a mean to reduce scan noise
  * The ability to fuzz for interesting files and directories as a mean to discover hidden information (similar to dirb)


  [Coming Soon]


  Arachnid can be hyper-customized to only search for information that is relevant to the user—however, it also comes preloaded with default scans that find generally useful or interesting information.  To use the default scan, users can simple issue the following command:

  ```
  arachnid https://www.example.com/
  ```

  This will launch a local php server that displays the visualized data. The output will be reloaded every 30 seconds to reflect newly found information.


  To help make this tool more useful, in addition to the default scan listed above, there are a few other preconfigured scan types that users can make use of.


  ```
  arachnid https://example.com --stealth
  ```
  A stealth scan will use the Google bot user agent, masking the crawler  instead of a regular firefox user. It also has a substantial delay between page requests to help make the scan less noisy. **This scan has the potential to take a long time to finish**


  ```
  arachnid https://example.com --aggressive
  ```

  An aggressive scan will ignore robots.txt rules and crawl all pages found on it. Aggressive also enables fuzzing for many pages and subdomains, and crawls at the fastest possible speed. This is ideally used when triggering alerts_IDS_WAF is not a concern.


  ```
  arachnid https://example.com/example_page.php --page-only
  ```

  Users can scrape a ingle web page instead of imitating a full site crawl. This is ideal if users want to scrape sensitive information from a data-rich page (such as a web directory)

  All predefined scan types are only a base plate of options. Users may override any options they provide by supplying additional arguments.


  Arachnid also allows users very granular control over how they want to scan to run. Here is a sample custom scan:
  ```
  arachnid https://example.com --aggressive --find docs phone --agent y --delay medium --doc ".psd" --string "John Doe" --regex "^\d{3}\s?\d{3}$" --fuzz --fuzz_subdomains

  ```

  Here is that scan broken down into its parts:
  ```
  https://example.com           : Required argument, specifies the domain to target
      --aggressive                  : Causes the formerly mentioned aggressive scan
      --find docs phone             : Only scrapes for common documents and phone numbers
      --agent y                     : Uses the Yahoo SearchBot header sting
      --delay medium                : Overrides the timing of the aggressive scan and causes a medium delay, or about 4-11 seconds
      --doc ".psd"                  : In addition to common docs, the crawler will also look for .psd files
      --string "John Doe"           : Searches for amount of occurances of "John Doe" on each page
      --regex  "^\d{3}\s?\d{3}$"    : Searches for any values that matches the provided regular expression
      --fuzz                        : Turns on page fuzzing which searchs for over 4000 common pages
      --fuzz_subdomains             : Turns on subdomain fuzzing which searchs for various common subdomains
  ```

  This does not represent all of the custom scan options available, but should give a snapshot of what Arachnid can do. For a full breakdown on each option please refer to the full documentation or use **arachnid —help**.


  Arachnid is a OSINT tool built to aid penetration testers, web developers, and system admins to scan an authorized domain for data leakage. While there is nothing inherently illegal about scanning or scraping information from a website users should use caution when using this tool:
  **Scanning and scraping can be considered the pretext to an attack**. Some security teams consider any OSINT recon the pretext to an attack and may pursue criminal charges if they are able to identify the source of the scans.

  **Aggressive scans might inadvertently cause a DoS**. This tool could possibly send out thousands of requests to a given server (depending on the size of the website and the fuzzing level set). If the server is not configured to handle that much bandwidth then this tool may inadvertently result in causing a denial-of-service (DoS). Even if it is unintentional, this could result in criminal charges.

  **This tool does not hide your identity**. While the stealth scans might modify the header information and timing to avoid IPS/IDS detection, it does not do anything to spoof or obfuscate the origin of the request. If users want to make their requests anonymous then they should consider routing their traffic through something like TOR or a VPN.
  In short, only use this tool to scan targets that you are authorized to scan, and that you know can handle the scan types that you configure. By using this Arachnid you agree to not use this tool if engage in malicious activity or scan unauthorized targets. In addition, the authors and contributors of this project are not responsible for any malicious usage or damage caused by this tool.


pkgId: 0da01f230fc1def3b8a670518bde0d8ebd112ae9b3617fb475143f70f2881e86
name: python-arang
arch: src
version: 1.0
epoch: 0
release: 1
summary: my own module for webhacking using python3
url: https://github.com/JaewookYou/arang
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arang-1.0-1.src.rpm
checksum_type: sha256
description:
  my own module for webhacking using python3



   - pip3 install arang
   - python3 -m pip install arang



   - pip3 install -U arang
   - python3 -m pip install -U arang





   - parse raw packet from `fiddler` or `burp suite`
   - send GET&POST by using `requests.session()` with `pp.*args`
   - set proxies server
   - set allow_redirects

  example code
  ```python
  from arang import *

  rawPacket='''GET http://ar9ang3.com/ HTTP/1.1
  Host: ar9ang3.com
  Connection: keep-alive
  Upgrade-Insecure-Requests: 1
  User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.105 Safari/537.36
  Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
  Accept-Encoding: gzip, deflate
  Accept-Language: ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7


  '''

  pp = parsePacket(rawPacket)
  print('-------parsed packet--------')
  print('pp.method - {}'.format(pp.method))
  print('pp.url - {}'.format(pp.url))
  print('pp.headers - {}'.format(pp.headers))
  print('pp.data - {}'.format(pp.data))
  print('----------------------------')

  pp.setProxy('192.168.20.80:8888')
  pp.redirect = False

  r = pp.post(pp.url,headers=pp.headers,data=pp.data)

  print(r.content)
  ```



   - parse `\$@#\d+#@\$`(example `$@#100#@$`) form and do intruder from raw packet of fiddler or burpsuite
   - can choose going up or down
   - can choose input as hex/decimal number
   - can save result with specific file
   - return requests result object by dictionary type
   - find some string value at response content & print it

  ```python
  rawPacket='''GET http://ar9ang3.com/?$@#100#@$ HTTP/1.1
  Host: ar9ang3.com
  Connection: keep-alive
  Upgrade-Insecure-Requests: 1
  User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.105 Safari/537.36
  Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
  Accept-Encoding: gzip, deflate
  Accept-Language: ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7


  '''

  print('[+] upper intruder test - hexed=True, verbose=False, showContent=False, resultSaveWithFile="result.txt"')
  rr = pp.sequentialIntruder(rawPacket, to=0x110, option='upper', hexed=True, verbose=False, showContent=False, resultSaveWithFile='result.txt')
  print(rr)
  '''
  result
  {256: <Response [200]>, 257: <Response [200]>, 258: <Response [200]>, 259: <Response [200]>, 260: <Response [200]>, 261: <Response [200]>, 262: <Response [200]>, 263: <Response [200]>, 264: <Response [200]>, 265: <Response [200]>, 266: <Response [200]>, 267: <Response [200]>, 268: <Response [200]>, 269: <Response [200]>, 270: <Response [200]>, 271: <Response [200]>, 272: <Response [200]>}
  '''

  print('-====================-')

  print('[+] lower intruder test - option="lower", find="arang", verbose=True')
  rr = pp.sequentialIntruder(rawPacket, to=90, option='lower', verbose=True)
  print(rr)
  '''
  result
  {100: <Response [200]>, 99: <Response [200]>, 98: <Response [200]>, 97: <Response [200]>, 96: <Response [200]>, 95: <Response [200]>, 94: <Response [200]>, 93: <Response [200]>, 92: <Response [200]>, 91: <Response [200]>, 90: <Response [200]>}
  '''
  ```


   - urlencode / urldecode / ue / ud
   - b64encode / b64decode / be / bd
   - hexencode / hexdecode / he / hd
   - md5, sha1, sha256


  ```python
  print('\n\n[+] misc util test.. url,b64,hex,hash\n')
  string = 'ABCD!@#$'
  print(f'urlencode : {string} - {urlencode(string)}')
  print(f'urlencode : {string} - {urlencode(string, enc='cp949')}')
  print(f'urldecode : {urlencode(string)} - {urldecode(urlencode(string))}')
  print(f'urldecode : {urlencode(string)} - {urldecode(urlencode(string, enc='cp949'), enc='cp949')}')
  print(f'b64encode : {string} - {b64encode(string)}')
  print(f'b64decode : {b64encode(string)} - {b64decode(b64encode(string))}')
  print(f'hexencode : {string} - {hexencode(string)}')
  print(f'hexdecode : {hexencode(string)} - {hexdecode(hexencode(string))}')
  print(f'md5       : {string} - {md5(string)}')
  print(f'sha1      : {string} - {sha1(string)}')
  print(f'sha256    : {string} - {sha256(string)}')
  ```



  1. support threadpoolexecutor at intruder for increasing exploit speed
  2. implement oob helper with simple webserver (idea from [Zach Wade](https://twitter.com/zwad3))
  3. implement `request smuggling` helper(or tool)
  4. implement automating blind sql injection




  ```
  - fix string encoding issue with url,base64,hex encode/decode functions
  - add short version of encode/decode functions
  - support user defined encoding with urlencode/urldecode functions
  ```



  Copyright (C) Jaewook You(arang) (jaewook376 at naver dot com)

  License: GNU General Public License, version 2


pkgId: 20edb2aa2b0a9b6d620e3a8a60e0f50da73f4516dab7417334674175241e59b7
name: python-arango-datasets
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: Package for fetching and loading datasets for ArangoDB deployments.
url: https://github.com/arangoml/arangodb_datasets
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arango-datasets-1.2.2-1.src.rpm
checksum_type: sha256
description:
  Package for loading example datasets into an ArangoDB Instance.

  ```py
  from arango import ArangoClient
  from arango_datasets import Datasets


  db = ArangoClient(hosts='http://localhost:8529').db("dbName", username="root", password="")

  datasets = Datasets(db)


  datasets.list_datasets()


  datasets.dataset_info("IMDB_X")


  datasets.load("IMDB_X")
  ```


pkgId: 697db2856f7ee52218f463b91690f2ef583316b4665c04ec078f501060d57bf3
name: python-arango-orm
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: A SQLAlchemy like ORM implementation for arangodb
url: https://arango-orm.compulife.com.pk
rpm_license: GNU General Public License v2 (GPLv2)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arango-orm-1.1.0-1.src.rpm
checksum_type: sha256
description:
  **arango_orm** is a python ORM layer inspired by SQLAlchemy but aimed to work
  with the multi-model database [ArangoDB](https://www.arangodb.com). It supports accessing both collections
  and graphs using the ORM. The actual communication with the database is done
  using [python-arango](https://docs.python-arango.com) (the database driver for accessing arangodb from
  python) and object serialization, validation, etc is handled by [pydantic](https://docs.pydantic.dev/latest/).





  ```shell
  pip install arango-orm
  ```




  ```python
  from arango import ArangoClient
  from arango_orm import Database

  client = ArangoClient(hosts='http://localhost:8529')
  test_db = client.db('test', username='test', password='test')

  db = Database(test_db)
  ```



  ```python
  from datetime import date
  from pydantic import Field
  from arango_orm import Collection


  class Student(Collection):

      __collection__ = 'students'

      name: str
      dob: date
  ```




  ```python
  db.create_collection(Student)
  ```



  ```python
  db.drop_collection(Student)
  ```



  ```python
  db.has_collection(Student)
  db.has_collection('students')
  ```



  ```python
  from datetime import date
  s = Student(name='test', _key='12312', dob=date(year=2016, month=9, day=12))
  db.add(s)
  print(s._id)  # students/12312
  ```




  ```python
  db.query(Student).count()
  ```




  ```python
  s = db.query(Student).by_key('12312')
  ```



  ```python
  s = db.query(Student).by_key('12312')
  s.name = 'Anonymous'
  db.update(s)
  ```



  ```python
  s = db.query(Student).by_key('12312')
  db.delete(s)
  ```



  ```python
  students = db.query(Student).all()
  ```



  ```python
  first_student = db.query(Student).first()
  ```



  Using bind parameters (recommended)

  ```python
  records = db.query(Student).filter("name==@name", name='Anonymous').all()
  ```

  Using plain condition strings (not safe in case of unsanitized user supplied input)

  ```python
  records = db.query(Student).filter("name=='Anonymous'").all()
  ```



  ```python

  records = db.query(Student).filter(
              "LIKE(rec.name, 'A%')", prepend_rec_name=False).filter(
              "LIKE(rec.name, 'B%')", prepend_rec_name=False, _or=True).all()
  ```



  ```python

  records = db.query(Student).filter(
              "LIKE(rec.name, 'A%')", prepend_rec_name=False).sort("name DESC").limit(5).all()


  page_num, per_page = 2, 10
  page = db.query(Student).sort("name DESC").limit(per_page, start_from=(page_num - 1) * per_page)
  ```




  ```python
  c = db.query(Student).limit(2).returns('_key', 'name').first()
  ```



  ```python
  db.query(Student).filter("name==@name", name='Anonymous').update(name='Mr. Anonymous')
  ```



  ```python
  db.query(Student).filter("LIKE(rec.name, 'test%')", prepend_rec_name=False).delete()
  ```



  ```python
  db.query(Student).delete()
  ```




  ```python
  s1 = Student(name='test1', _key='12345', dob=date(year=2016, month=9, day=12))
  s2 = Student(name='test2', _key='22346', dob=date(year=2015, month=9, day=12)
  car1 = Car(make="Honda", model="Fiat", year=2010)
  car2 = Car(make="Honda", model="Skoda", year=2015)

  db.bulk_add(entity_list=[p_ref_10, p_ref_11, car1, car2])
  ```



  ```python
  p_ref1 = db.query(Person).by_key("12312")
  p_ref2 = db.query(Person).by_key("12345")
  p_ref1.name = "Bruce"
  p_ref2.name = "Eliza"
  db.bulk_update(entity_list=[p_ref1, p_ref2])
  ```



  ```python
  db.add(Student(name='test1', _key='12345', dob=date(year=2016, month=9, day=12)))
  db.add(Student(name='test2', _key='22346', dob=date(year=2015, month=9, day=12)))

  students = [Student._load(s) for s in db.aql.execute("FOR st IN students RETURN st")]
  ```



  Reference fields allow linking documents from another collection class within a collection instance.
  These are similar in functionality to SQLAlchemy's relationship function.

  ```python
  from arango import ArangoClient
  from arango_orm.database import Database

  from arango_orm.fields import String
  from arango_orm import Collection, Relation, Graph, GraphConnection
  from arango_orm.references import relationship, graph_relationship


  class Person(Collection):

      __collection__ = 'persons'

      _index = [{'type': 'hash', 'unique': False, 'fields': ['name']}]
      _allow_extra_fields = False  # prevent extra properties from saving into DB

      _key = String(required=True)
      name = String(required=True, allow_none=False)

      cars = relationship(__name__ + ".Car", '_key', target_field='owner_key')

      def __str__(self):
          return "<Person(" + self.name + ")>"


  class Car(Collection):

      __collection__ = 'cars'
      _allow_extra_fields = True

      make = String(required=True)
      model = String(required=True)
      year = Integer(required=True)
      owner_key = String()

      owner = relationship(Person, 'owner_key', cache=False)

      def __str__(self):
          return "<Car({} - {} - {})>".format(self.make, self.model, self.year)

  client = ArangoClient(hosts='http://localhost:8529')
  test_db = client.db('test', username='test', password='test')
  db = Database(test_db)

  p = Person(_key='kashif', name='Kashif Iftikhar')
  db.add(p)
  p2 = Person(_key='azeen', name='Azeen Kashif')
  db.add(p2)

  c1 = Car(make='Honda', model='Civic', year=1984, owner_key='kashif')
  db.add(c1)

  c2 = Car(make='Mitsubishi', model='Lancer', year=2005, owner_key='kashif')
  db.add(c2)

  c3 = Car(make='Acme', model='Toy Racer', year=2016, owner_key='azeen')
  db.add(c3)

  print(c1.owner)
  print(c1.owner.name)
  print(c2.owner.name)
  print(c3.owner.name)

  print(p.cars)
  print(p.cars[0].make)
  print(p2.cars)
  ```



  Working with graphs involves creating collection classes and optionally Edge/Relation classes. Users can use the built-in Relation class for specifying relations but if relations need to contain extra attributes then it's required to create a sub-class of Relation class. Graph functionality is explain below with the help of a university graph example containing students, teachers, subjects and the areas where students and teachers reside in.

  First we create some collections and relationships

  ```python
  from typing import Literal
  from arango_orm import Collection, Relation, Graph, GraphConnection


  class Student(Collection):

      __collection__ = 'students'

      name: str
      age: int | None = None

      def __str__(self):
          return "<Student({})>".format(self.name)


  class Teacher(Collection):

      __collection__ = 'teachers'

      name: str

      def __str__(self):
          return "<Teacher({})>".format(self.name)


  class Subject(Collection):

      __collection__ = 'subjects'


      name: str
      credit_hours: int
      has_labs: bool = True

      def __str__(self):
          return "<Subject({})>".format(self.name)


  class Area(Collection):

      __collection__ = 'areas'



  class SpecializesIn(Relation):

      __collection__ = 'specializes_in'

      expertise_level: Literal["expert", "medium", "basic"]

      def __str__(self):
          return "<SpecializesIn(_key={}, expertise_level={}, _from={}, _to={})>".format(
              self.key_, self.expertise_level, self._from, self._to)
  ```

  Next we sub-class the Graph class to specify the relationships between the various collections

  ```python
  class UniversityGraph(Graph):

      __graph__ = 'university_graph'

      graph_connections = [
          
          GraphConnection(Student, Relation("studies"), Subject),
          GraphConnection(Teacher, Relation("teaches"), Subject),

          
          GraphConnection(Teacher, SpecializesIn, Subject),
          GraphConnection([Teacher, Student], Relation("resides_in"), Area)
      ]
  ```

  Now it's time to create the graph. Note that we don't need to create the collections individually, creating the graph will create all collections that it contains

  ```python
  from arango import ArangoClient
  from arango_orm.database import Database

  client = ArangoClient(hosts='http://localhost:8529')
  test_db = client.db('test', username='test', password='test')

  db = Database(test_db)

  uni_graph = UniversityGraph(connection=db)
  db.create_graph(uni_graph)
  ```

  Now the graph and all it's collections have been created, we can verify their existence:

  ```python
  [c['name'] for c in db.collections()]
  db.graphs()
  ```

  Now let's insert some data into our graph:

  ```python
  students_data = [
      Student(_key='S1001', name='John Wayne', age=30),
      Student(_key='S1002', name='Lilly Parker', age=22),
      Student(_key='S1003', name='Cassandra Nix', age=25),
      Student(_key='S1004', name='Peter Parker', age=20)
  ]

  teachers_data = [
      Teacher(_key='T001', name='Bruce Wayne'),
      Teacher(_key='T002', name='Barry Allen'),
      Teacher(_key='T003', name='Amanda Waller')
  ]

  subjects_data = [
      Subject(_key='ITP101', name='Introduction to Programming', credit_hours=4, has_labs=True),
      Subject(_key='CS102', name='Computer History', credit_hours=3, has_labs=False),
      Subject(_key='CSOOP02', name='Object Oriented Programming', credit_hours=3, has_labs=True),
  ]

  areas_data = [
      Area(_key="Gotham"),
      Area(_key="Metropolis"),
      Area(_key="StarCity")
  ]

  for s in students_data:
      db.add(s)

  for t in teachers_data:
      db.add(t)

  for s in subjects_data:
      db.add(s)

  for a in areas_data:
      db.add(a)
  ```

  Next let's add some relations, we can add relations by manually adding the relation/edge record into the edge collection, like:

  ```python
  db.add(SpecializesIn(_from="teachers/T001", _to="subjects/ITP101", expertise_level="medium"))
  ```

  Or we can use the graph object's relation method to generate a relation document from given objects:

  ```python
  gotham = db.query(Area).by_key("Gotham")
  metropolis = db.query(Area).by_key("Metropolis")
  star_city = db.query(Area).by_key("StarCity")

  john_wayne = db.query(Student).by_key("S1001")
  lilly_parker = db.query(Student).by_key("S1002")
  cassandra_nix = db.query(Student).by_key("S1003")
  peter_parker = db.query(Student).by_key("S1004")

  intro_to_prog = db.query(Subject).by_key("ITP101")
  comp_history = db.query(Subject).by_key("CS102")
  oop = db.query(Subject).by_key("CSOOP02")

  barry_allen = db.query(Teacher).by_key("T002")
  bruce_wayne = db.query(Teacher).by_key("T001")
  amanda_waller = db.query(Teacher).by_key("T003")

  db.add(uni_graph.relation(peter_parker, Relation("studies"), oop))
  db.add(uni_graph.relation(peter_parker, Relation("studies"), intro_to_prog))
  db.add(uni_graph.relation(john_wayne, Relation("studies"), oop))
  db.add(uni_graph.relation(john_wayne, Relation("studies"), comp_history))
  db.add(uni_graph.relation(lilly_parker, Relation("studies"), intro_to_prog))
  db.add(uni_graph.relation(lilly_parker, Relation("studies"), comp_history))
  db.add(uni_graph.relation(cassandra_nix, Relation("studies"), oop))
  db.add(uni_graph.relation(cassandra_nix, Relation("studies"), intro_to_prog))

  db.add(uni_graph.relation(barry_allen, SpecializesIn(expertise_level="expert"), oop))
  db.add(uni_graph.relation(barry_allen, SpecializesIn(expertise_level="expert"), intro_to_prog))
  db.add(uni_graph.relation(bruce_wayne, SpecializesIn(expertise_level="medium"), oop))
  db.add(uni_graph.relation(bruce_wayne, SpecializesIn(expertise_level="expert"), comp_history))
  db.add(uni_graph.relation(amanda_waller, SpecializesIn(expertise_level="basic"), intro_to_prog))
  db.add(uni_graph.relation(amanda_waller, SpecializesIn(expertise_level="medium"), comp_history))

  db.add(uni_graph.relation(bruce_wayne, Relation("teaches"), oop))
  db.add(uni_graph.relation(barry_allen, Relation("teaches"), intro_to_prog))
  db.add(uni_graph.relation(amanda_waller, Relation("teaches"), comp_history))

  db.add(uni_graph.relation(bruce_wayne, Relation("resides_in"), gotham))
  db.add(uni_graph.relation(barry_allen, Relation("resides_in"), star_city))
  db.add(uni_graph.relation(amanda_waller, Relation("resides_in"), metropolis))
  db.add(uni_graph.relation(john_wayne, Relation("resides_in"), gotham))
  db.add(uni_graph.relation(lilly_parker, Relation("resides_in"), metropolis))
  db.add(uni_graph.relation(cassandra_nix, Relation("resides_in"), star_city))
  db.add(uni_graph.relation(peter_parker, Relation("resides_in"), metropolis))
  ```

  With our graph populated with some sample data, let's explore the ways we can work with the graph.




  We can expand any Collection (not Relation) object to access the data that is linked to it. We can sepcify which links ('inbound', 'outbound', 'any') to expand and the depth to which those should be expanded to. Let's see all immediate connections that Bruce Wayne has in our graph:

  ```python
  bruce = db.query(Teacher).by_key("T001")
  uni_graph.expand(bruce, depth=1, direction='any')
  ```

  Graph expansion on an object adds a `_relations` dictionary that contains all the relations for the object according to the expansion criteria:

  ```python
  bruce._relations



  {
  'resides_in': [<Relation(_key=4205290, _from=teachers/T001, _to=areas/Gotham)>],
  'specializes_in': [<SpecializesIn(_key=4205114, expertise_level=medium, _from=teachers/T001, _to=subjects/ITP101)>,
      <SpecializesIn(_key=4205271, expertise_level=expert, _from=teachers/T001, _to=subjects/CS102)>,
      <SpecializesIn(_key=4205268, expertise_level=medium, _from=teachers/T001, _to=subjects/CSOOP02)>],
  'teaches': [<Relation(_key=4205280, _from=teachers/T001, _to=subjects/CSOOP02)>]
  }
  ```

  We can use _from and _to of a relation object to access the id's for both sides of the link. We also have _object_from and _object_to to access the objects on both sides, for example:

  ```python
  bruce._relations['resides_in'][0]._object_from.name


  bruce._relations['resides_in'][0]._object_to._key

  ```

  There is also a special attribute called `_next` that allows accessing the other side of the relationship irrespective of the relationship direction. For example, for outbound relationships the `_object_from` contains the source object while for inbound_relationships `_object_to` contains the source object. But if we're only interested in traversal of the graph then it's more useful at times to access the other side of the relationship w.r.t the current object irrespective of it's direction:

  ```python
  bruce._relations['resides_in'][0]._next._key

  ```

  Let's expand the bruce object to 2 levels and see `_next` in more action:

  ```python
  uni_graph.expand(bruce, depth=2)


  bruce._relations['resides_in'][0]._object_to._relations



  bruce._relations['resides_in'][0]._object_to._relations['resides_in'][0]._object_from.name



  bruce._relations['resides_in'][0]._next._relations['resides_in'][0]._next.name



  [p._next.name for p in bruce._relations['resides_in'][0]._next._relations['resides_in']]

  ```




  For inheritance mapping, **arango_orm** offers you two ways to define it.



  Discriminator field/mapping are defined at entity level:

  ```python
  class Vehicle(Collection):
      __collection__ = "vehicle"

      _inheritance_field = "discr"
      _inheritance_mapping = {
          'Bike': 'moto',
          'Truck': 'truck'
      }

      _key = String()
      brand = String()
      model = String()
      
      
      discr = String(required=True)


  class Bike(Vehicle):
      motor_size = Float()


  class Truck(Vehicle):
      traction_power = Float()
  ```



  The `inheritance_mapping_resolver` is a function defined at graph level; it allows you to make either a simple test
  on a discriminator field, or complex inference

  ```python
  class OwnershipGraph2(Graph):
      __graph__ = "ownership_graph"

      graph_connections = [
          GraphConnection(Owner2, Own2, Vehicle2)
      ]

      def inheritance_mapping_resolver(self, col_name: str, doc_dict: dict = {}):
          if col_name == 'vehicle':
              if 'traction_power' in doc_dict:
                  return Truck2
              else:
                  return Bike2

          return self.vertices[col_name]
  ```



  The graph module also supports traversals using AQL, the results are converted to objects and have the
  same structure as graph.expand method:

  ```python
  obj = uni_graph.aql("FOR v, e, p IN 1..2 INBOUND 'areas/Gotham' GRAPH 'university_graph' RETURN p")
  print(obj._key)


  gotham_residents = [rel._next.name for rel in obj._relations['resides_in']]
  print(gotham_residents)

  ```






  Set env variables in .env file, then load the env

  ```shell
  set -a; source .env; set +a
  ```

  Afterwards run tests

  ```
  poetry run pytest
  ```


pkgId: c401983443eb152309e396635d250826d66ec04e50cce831dce9e15c8353545d
name: python-aranizer
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: Aranizer: A Custom Tokenizer for Enhanced Arabic Language Processing
url: https://github.com/riotu-lab/aranizer
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aranizer-0.2.5-1.src.rpm
checksum_type: sha256
description:
  `AraNizer` is a sophisticated toolkit of custom tokenizers tailored for Arabic language processing. Integrating advanced methodologies such as SentencePiece and Byte Pair Encoding (BPE), these tokenizers are specifically designed for seamless integration with the `transformers` and `sentence_transformers` libraries. The `AraNizer` suite offers a range of tokenizers, each optimized for distinct NLP tasks and accommodating varying vocabulary sizes to cater to a multitude of linguistic applications.


  - **Versatile Tokenization:** Supports multiple tokenization strategies (BPE, SentencePiece) for varied NLP tasks.
  - **Broad Vocabulary Range:** Customizable tokenizers with vocabulary sizes ranging from 32k to 86k.
  - **Seamless Integration:** Compatible with popular libraries like transformers and sentence_transformers.
  - **Optimized for Arabic:** Specifically engineered for the intricacies of the Arabic language.


  Install AraNizer effortlessly with pip:
  ```bash
  pip install aranizer
  ```



  Import your desired tokenizer from AraNizer. Available tokenizers include:
  BEP variants: get_bpe with keys bpe32, bpe50, bpe64, bpe86, bpe32T, bpe50T, bpe64T, bpe86T
  SentencePiece variants: get_sp with keys sp32, sp50, sp64, sp86, sp32T, sp50T, sp64T, sp86T

  ```python
  from aranizer import get_bpe, get_sp  # Import functions to retrieve tokenizers


  bpe_tokenizer = get_bpe("bpe32")  # Replace with your chosen tokenizer key


  sp_tokenizer = get_sp("sp32")  # Replace with your chosen tokenizer key
  ```


  Tokenize Arabic text using the selected tokenizer:

  ```python
  text = "مثال على النص العربي"  # Example Arabic text


  bpe_tokens = bpe_tokenizer.tokenize(text)
  print(bpe_tokens)


  sp_tokens = sp_tokenizer.tokenize(text)
  print(sp_tokens)
  ```



  Encode text into token ids and decode back to text.

  **Encoding:** To encode text, use the encode method.
  ```python
  text = "مثال على النص العربي"  # Example Arabic text


  encoded_bpe_output = bpe_tokenizer.encode(text, add_special_tokens=True)
  print(encoded_bpe_output)


  encoded_sp_output = sp_tokenizer.encode(text, add_special_tokens=True)
  print(encoded_sp_output)
  ```

  **Decoding:** To convert token ids back to text, use the decode method:
  ```python

  decoded_bpe_text = bpe_tokenizer.decode(encoded_bpe_output)
  print(decoded_bpe_text)


  decoded_sp_text = sp_tokenizer.decode(encoded_sp_output)
  print(decoded_sp_text)
  ```



  ```bash
  Available Tokenizers
  get_bpe("bpe32"): Based on BPE Tokenizer with Vocab Size of 32k
  get_bpe("bpe50"): Based on BPE Tokenizer with Vocab Size of 50k
  get_bpe("bpe64"): Based on BPE Tokenizer with Vocab Size of 64k
  get_bpe("bpe86"): Based on BPE Tokenizer with Vocab Size of 86k
  get_bpe("bpe32T"): Based on BPE Tokenizer with Vocab Size of 32k (with Tashkeel (diacritics))
  get_bpe("bpe50T"): Based on BPE Tokenizer with Vocab Size of 50k (with Tashkeel (diacritics))
  get_bpe("bpe64T"): Based on BPE Tokenizer with Vocab Size of 64k (with Tashkeel (diacritics))
  get_bpe("bpe86T"): Based on BPE Tokenizer with Vocab Size of 86k (with Tashkeel (diacritics))
  get_sp("sp32"): Based on SentencePiece Tokenizer with Vocab Size of 32k
  get_sp("sp50"): Based on SentencePiece Tokenizer with Vocab Size of 50k
  get_sp("sp64"): Based on SentencePiece Tokenizer with Vocab Size of 64k
  get_sp("sp86"): Based on SentencePiece Tokenizer with Vocab Size of 86k
  get_sp("sp32T"): Based on SentencePiece Tokenizer with Vocab Size of 32k (with Tashkeel (diacritics))
  get_sp("sp50T"): Based on SentencePiece Tokenizer with Vocab Size of 50k (with Tashkeel (diacritics))
  get_sp("sp64T"): Based on SentencePiece Tokenizer with Vocab Size of 64k (with Tashkeel (diacritics))
  get_sp("sp86T"): Based on SentencePiece Tokenizer with Vocab Size of 86k (with Tashkeel (diacritics))
  ```


  - Python 3.x
  - transformers library


  For queries or assistance, please contact riotu@psu.edu.sa.


  This work is maintained by the Robotics and Internet-of-Things Lab at Prince Sultan University.


  - Prof. Anis Koubaa (Lab Leader)
  - Dr. Lahouari Ghouti (NLP Team Leader)
  - Eng. Omar Najjar (AI Research Assistant)
  - Eng. Serry Sebai (NLP Research Engineer)


  0.2.3


  Coming soon


pkgId: 23385b8af1c78f900efe3270fd83ff125f7ededc16000c2f555167e9b42944f7
name: python-arbol
arch: src
version: 2021.5.27.641
epoch: 0
release: 1
summary: arbol -- Arborescent Printouts in Python
url: https://github.com/royerlab/arbol
rpm_license: BSD 3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arbol-2021.5.27.641-1.src.rpm
checksum_type: sha256
description:
  ![s](arbol.png)
  Do you have a script, a command line tool, or some workflow in Python that has lots of 'print' statements,
  and you can't make sense of it once it adds up to hundreds of lines on the console? Sounds familiar?
  _arbol_ organises your stdout prints in a hierarchy that follows the structure of your code. Use a simple
  context manager to define the hierarchy and the 'aprint' command instead of print, and voila.
  Finally, when the optional dependencies are installed, the printed tree and text are colored with an
  exquisitely crafted combination of colors, making it even more visually appealing.

  If you are wondering, 'arbol' means 'tree' in spanish.

  Why not use a more traditional Python logging? We have made the choice of sticking to a plain and simple
  scheme that matches the usage of 'print' statements.



  You can use 'aprint' replacement for the built-in 'print'.
  You create a new 'node' in the tree with the 'asection' contact manager. Moreover, _arbol_ measures the elapsed time for each node of the tree and displays that conveniently.
  You have several configuration flags in the Arbol class to tune things. If yo want to capture print statements originating from 3rd party code,
  you can use the 'acapture' context manager to capture stdout (and stderr) -- tis is a bit experimental and is best used sparingly.
  The best documentation is simply the demo below...



  Install with pip:

  ```sh
  pip install arbol
  ```



  If you want colors, install the [ansicolors](https://pypi.org/project/ansicolors/) package:

  ```sh
  pip install ansicolors
  ```

  To make sure that you get the colors on all operating systems (particularly Windows), install the [colorama](https://pypi.org/project/colorama/)
  package:

  ```sh
  pip install colorama
  ```

  Note: both colorama and ansicolors are optional -- _arbol_ will work fine without it installed.


  Here is a simple and self-explanatory example:
  ```python

  from arbol import Arbol, aprint, section, asection, acapture

  import arbol





  Arbol.max_depth = 4


  aprint('Test')


  @section('function')
  def fun(x):
      if x >= 0:
          with asection('recursive call to f'):
              aprint(f"f(x)+1={fun(x - 1)}")


  with asection('a section'):
      aprint('a line')
      aprint('another line')
      aprint('we are done \n or are we? \n someone gotta check!')

      with asection('a subsection'):
          aprint('another line')
          aprint('we are done')

      
      fun(2)

      
      with acapture():
          print("No escape is possible")
          aprint("Even this works...\n")
          

      
      Arbol.elapsed_time = False
      fun(100)

  aprint('demo is finished...')


  Arbol.enable_output = False
  aprint('you will not see that')


  ```

  And this is how it looks like:

  ![example](example.png)


  Some ideas we might consider from serious to highly speculative:
  - More color styles to choose from
  - Intercept stdout from C code so that printouts from libraries called from python are formatted too, unclear is that's possible.
  - Generate tree automatically by inspecting stack?
  - Interoperability with logging package?
  - How to handle multiple threads/processes? Right now, the printouts get inter;leaved stochastically which is messy and incomprehensible. One idea is to capture all outputs from each thread, hold onto these outputs until the thread is done (perhaps via a dedicated 'holding' context manager), and ouput it all in order and separately. Probably doable.



  Pull requests highly welcome!



  Loic A. Royer (@loicaroyer)
  Ahmet Can Solak (@_ahmetcansolak)


pkgId: ef83c56899c4bdae2bb1598e2ee07f5ce6cbead17082f31fa7869739812fedf1
name: python-arbow
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Cultivate your MSA to get better trees
url: https://github.com/MDPHL/arbow
rpm_license: GNU Lesser General Public License v3 (LGPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arbow-0.6.0-1.src.rpm
checksum_type: sha256
description:
                                  [default: 5]
    -io, --iqtree-outgroup TEXT     ID(s) of samples to be used as outgroup in
                                    IQTree. (e.g., single: sample_1, multiple:
                                    'sample_2,sample_3'. This option is ignore
                                    if --use-ref-as-outgroup is selected.
    -r, --ref-id TEXT              Sequence ID of the reference  [default:
                                   MN908947.3]
    -u, --use-ref-as-outgroup       Use the reference sequence as the outgroup
                                    in IQTree  [default: False]
    --five-prime-end INTEGER       Last base of the 5' UTR region in 1-index in
                                   the ref sequence  [default: 265]
    --three-prime-start INTEGER    First base of the 3' UTR region in 1-index in
                                   the ref sequence  [default: 29675]
    --include-const                When outputting the clean alignment, leave
                                   constant sites in the alignment. [default is
                                   to remove]
    -l, --log FILENAME             Log file to store output. Use '-' to log to
                                   stdout  [default:
                                   arbow-2020-05-05-153619.log]
    --help                        Show this message and exit.
  ```

  By default, `arbow` will trim the 5' and 3' UTR regions.

  Let us say that you wish to remove all sites in the alignment that have **any** missing data, and retain all complete columns:
  ```
  arbow -x 1.0 -mc 0 <in.aln>
  ```

  Let us say that you wish to keep all sites in the alignment, and you have an alignment with 200 sequences:
  ```
  arbow <in.aln>
  ```

  ```
  arbow --include-const <in.aln>
  ```

  ```
  arbow <-h|--help>
  ```

  ```
  arbow --version
  ```


pkgId: 7f40135a0ae0744015cf283f9301ea5b1189e6948949d95d622f110aa3f59374
name: python-arbytmap
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: A texture manipulation module for python 3.
url: https://github.com/Sigmmma/arbytmap
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arbytmap-1.1.2-1.src.rpm
checksum_type: sha256
description:
  * Arbytmap is a bitmap conversion and manipulation module. Arbytmap is intended for use in converting bitmaps from one format to another, half-rezzing and generating mipmaps, swizzling bitmaps, and writing converted bitmaps to files. Arbytmap is currently undergoing a large scale cleanup, as much of it was written years ago when I was a much worse programmer.

  * Many of the conversion functions have accelerator modules written in C, so this module(if properly compiled and installed) can reach speeds seen in lower level languages.

  * Raw formats currently supported by this module are as follows:
  ```A8, Y8, AY8, A8Y8, R3G3B2, 5G6B5, R8G8B8, Y8U8V8, A1R5G5B5, A4R4G4B4, X8R8G8B8, A8R8G8B8, R16G16B16, A16R16G16B16```

  * DXT formats currently supported by this module are as follows:
  ```DXT1/2/3/4/5, DXN, DXT5A, DXT5Y, DXT5AY, CTX1, U8V8```



  * Clean up and standardize the interface for loading bitmaps and conversion settings into the Arbytmap class.

  * Cleanup/redo pretty much everything that looks/functions bad.



  * Devin Bobadilla (Author of arbytmap) mosesbobadilla@gmail.com


pkgId: 56e1dd1207c00fe64fc9a905491a88d8e9331cf0e8084d8bac36e2f62625219d
name: python-arc-cli
arch: src
version: 8.6.3
epoch: 0
release: 1
summary: Package for creating CLI's with ease.
url: https://github.com/seanrcollings/arc
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arc-cli-8.6.3-1.src.rpm
checksum_type: sha256
description:
  A tool for building declarative, and highly extendable CLI systems for Python 3.10+


  - Command line arguments based on python type hints
  - Arbitrary command nesting
  - Automatic `--help` documentation
  - Fully Extensible with custom middlewares,  types, validators, parameter configurations, etc...


  - [Docs](https://arc.seancollings.dev)
  - [Playground](https://playground.arc.seancollings.dev)
  - [PyPi](https://pypi.org/project/arc-cli/)




  ```py
  import arc

  @arc.command
  def hello(name: str):
      """My first arc program!"""
      arc.print(f"Hello {name}!")

  hello()
  ```

  ```
  $ python hello.py Sean
  Hello, Sean!
  ```

  ```
  $ python hello.py --help
  USAGE
      hello.py [-h] [--] name

  DESCRIPTION
      My first arc program!

  ARGUMENTS
      name

  OPTIONS
      --help (-h)  Displays this help message
  ```



  ```
  $ pip install arc-cli
  ```

  Clone for development
  ```
  $ git clone https://github.com/seanrcollings/arc
  $ poetry install
  ```


  Tests are written with `pytest`
  ```
  $ pytest
  ```


pkgId: ad5967e500df708b1e0ee67a6300abc159ee0b9772accc4f25eaa33324e4a9fc
name: python-arc4
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: A small and insanely fast ARCFOUR (RC4) cipher implementation of Python
url: https://github.com/manicmaniac/arc4
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arc4-0.4.0-1.src.rpm
checksum_type: sha256
description:
  A small and insanely fast ARCFOUR (RC4) cipher implementation of Python.
  * Strongly focused on performance; entire source code is written in C.
  * Thread-safety; you can improve further performance with multi-threading.
  * Easily installable; single file with no dependency, pre-built wheels provided.


pkgId: 32f6631d0edcd8b47cacf69a02d276aeec3bff2a1ee1649d06bdb2b1441a4b67
name: python-arcade-collection
arch: src
version: 0.16.0
epoch: 0
release: 1
summary: Collection of tasks for working with ARCADE.
url: https://pypi.org/project/arcade-collection/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcade-collection-0.16.0-1.src.rpm
checksum_type: sha256
description:
  [![Build status](https://bagherilab.github.io/arcade-collection/_badges/build.svg)](https://github.com/bagherilab/arcade-collection/actions?query=workflow%3Abuild)
  [![Lint status](https://bagherilab.github.io/arcade-collection/_badges/lint.svg)](https://github.com/bagherilab/arcade-collection/actions?query=workflow%3Alint)
  [![Documentation](https://bagherilab.github.io/arcade-collection/_badges/documentation.svg)](https://bagherilab.github.io/arcade-collection/)
  [![Coverage](https://bagherilab.github.io/arcade-collection/_badges/coverage.svg)](https://bagherilab.github.io/arcade-collection/_coverage/)
  [![Code style](https://bagherilab.github.io/arcade-collection/_badges/style.svg)](https://github.com/psf/black)
  [![Version](https://bagherilab.github.io/arcade-collection/_badges/version.svg)](https://pypi.org/project/arcade-collection/)
  [![License](https://bagherilab.github.io/arcade-collection/_badges/license.svg)](https://github.com/bagherilab/arcade-collection/blob/main/LICENSE)

  Collection of tasks for working with ARCADE.
  Designed to be used both in [Prefect](https://docs.prefect.io/latest/) workflows and as modular, useful pieces of code.



  The collection can be installed using:

  ```bash
  pip install arcade-collection
  ```

  We recommend using [Poetry](https://python-poetry.org/) to manage and install dependencies.
  To install into your Poetry project, use:

  ```bash
  poetry add arcade-collection
  ```





  All tasks in this collection are wrapped in a Prefect `@task` decorator, and can be used directly in a Prefect `@flow`.
  Running tasks within a [Prefect](https://docs.prefect.io/latest/) flow enables you to take advantage of features such as automatically retrying failed tasks, monitoring workflow states, running tasks concurrently, deploying and scheduling flows, and more.

  ```python
  from prefect import flow
  from arcade_collection.<module_name> import <task_name>

  @flow
  def run_flow():
      <task_name>()

  if __name__ == "__main__":
      run_flow()
  ```

  See [cell-abm-pipeline](https://github.com/allen-cell-animated/cell-abm-pipeline) for examples of using tasks from different collections to build a pipeline for simulating and analyzing agent-based model data.



  Not all use cases require a full workflow.
  Tasks in this collection can be used without the Prefect `@task` decorator by simply importing directly from the module:

  ```python
  from arcade_collection.<module_name>.<task_name> import <task_name>

  def main():
      <task_name>()

  if __name__ == "__main__":
      main()
  ```

  or using the `.fn()` method:

  ```python
  from arcade_collection.<module_name> import <task_name>

  def main():
      <task_name>.fn()

  if __name__ == "__main__":
      main()
  ```


pkgId: 6aeac20dd83ca9b0eb461dafdccadd2780b300687e0acec6a857dfc225da8c27
name: python-arcade-local-file-management
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: LLM tools for tasks relating to folder and file management that are stored locally
url: https://pypi.org/project/arcade-local-file-management/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcade-local-file-management-0.1.5-1.src.rpm
checksum_type: sha256
description:
  This is an Arcade AI toolkit for managing local files. It includes tools for reading, writing, and searching files.



  ```bash
  pip install arcade-local-file-management
  ```

  [GitHub](https://github.com/EricGustin/https://github.com/EricGustin/local_file_management)


pkgId: 2fb17167175275c341000728b452f68df8a2d49c7410808407493cc853e7ac9f
name: python-arcade_notion
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Notion integration to search, create, update, and delete databases/pages.
url: https://pypi.org/project/arcade_notion/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcade_notion-0.1.1-1.src.rpm
checksum_type: sha256
description:
  An Arcade AI toolkit designed to interact with Notion, enabling users to find and create pages and databases.



  - **Page & Database Discovery**: Easily find pages and databases by their titles and get their IDs for follow-up operations
  - **Content Creation**: Generate new pages and databases with AI-assisted content population
  - **Secure OAuth Integration**: Built-in secure authentication flow with Notion's OAuth 2.0



  - [ ] Update existing pages and databases
  - [ ] Delete pages and databases



  Before getting started, ensure you have:

  - A Notion account with administrative access
  - Permission to create and manage integrations
  - Access to target pages/databases





  1. Follow the [Create a Public Integration](https://developers.notion.com/docs/authorization#public-integration-auth-flow-set-up) guide
  2. Set the redirect URI to: `https://cloud.arcade-ai.com/api/v1/oauth/callback`
  3. Save your client ID and secret



  Add these variables to your `arcade.env`:

  ```env
  NOTION_CLIENT_ID=your_client_id
  NOTION_CLIENT_SECRET=your_client_secret
  ```



  Add this configuration to your Arcade engine setup:

  ```yaml
  auth:
    providers:
      - id: notion
        enabled: true
        type: oauth2
        description: "Notion OAuth 2.0 provider"
        client_id: ${env:NOTION_CLIENT_ID}
        client_secret: ${env:NOTION_CLIENT_SECRET}
        oauth2:
          authorize_request:
            endpoint: "https://api.notion.com/v1/oauth/authorize"
            params:
              response_type: "code"
              client_id: "{{client_id}}"
              redirect_uri: "{{redirect_uri}}"
              owner: "user"
          token_request:
            endpoint: "https://api.notion.com/v1/oauth/token"
            params:
              grant_type: "authorization_code"
              redirect_uri: "{{redirect_uri}}"
            auth_method: "client_secret_basic"
  ```





  ```plaintext

  "Get me the database ID for 'Project Tracker'"


  "What's the ID of the page called 'Meeting Notes'?"
  ```



  ```plaintext

  "Create a new page titled 'Mobile App Redesign' in the 'Project Ideas' database and populate it with ideas generated from our recent discussion"



  "Create a new page titled 'Client Discussion' within the 'Meeting Notes' database, including all the notes from today's meeting"
  ```


pkgId: f461c219800edaa2054c633af8b29eb643cda01a8955ebf8b38b5128511d3127
name: python-arcadepy
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: The official Python library for the Arcade API
url: https://github.com/ArcadeAI/arcade-py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcadepy-0.2.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/arcadepy.svg)](https://pypi.org/project/arcadepy/)

  The Arcade Python library provides convenient access to the Arcade REST API from any Python 3.8+
  application. The library includes type definitions for all request params and response fields,
  and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).

  It is generated with [Stainless](https://www.stainlessapi.com/).



  The REST API documentation can be found on [docs.arcade-ai.com](https://docs.arcade-ai.com). The full API of this library can be found in [api.md](https://github.com/ArcadeAI/arcade-py/tree/main/api.md).



  ```sh

  pip install arcadepy
  ```



  The full API of this library can be found in [api.md](https://github.com/ArcadeAI/arcade-py/tree/main/api.md).

  ```python
  import os
  from arcadepy import Arcade

  client = Arcade(
      api_key=os.environ.get("ARCADE_API_KEY"),  # This is the default and can be omitted
  )

  response = client.tools.execute(
      tool_name="Google.ListEmails",
      inputs={"n_emails": 10},
      user_id="user@example.com",
  )
  print(response.invocation_id)
  ```

  While you can provide an `api_key` keyword argument,
  we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
  to add `ARCADE_API_KEY="My API Key"` to your `.env` file
  so that your API Key is not stored in source control.



  Simply import `AsyncArcade` instead of `Arcade` and use `await` with each API call:

  ```python
  import os
  import asyncio
  from arcadepy import AsyncArcade

  client = AsyncArcade(
      api_key=os.environ.get("ARCADE_API_KEY"),  # This is the default and can be omitted
  )


  async def main() -> None:
      response = await client.tools.execute(
          tool_name="Google.ListEmails",
          inputs={"n_emails": 10},
          user_id="user@example.com",
      )
      print(response.invocation_id)


  asyncio.run(main())
  ```

  Functionality between the synchronous and asynchronous clients is otherwise identical.



  Nested request parameters are [TypedDicts](https://docs.python.org/3/library/typing.html#typing.TypedDict). Responses are [Pydantic models](https://docs.pydantic.dev) which also provide helper methods for things like:

  - Serializing back into JSON, `model.to_json()`
  - Converting to a dictionary, `model.to_dict()`

  Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, set `python.analysis.typeCheckingMode` to `basic`.



  When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `arcadepy.APIConnectionError` is raised.

  When the API returns a non-success status code (that is, 4xx or 5xx
  response), a subclass of `arcadepy.APIStatusError` is raised, containing `status_code` and `response` properties.

  All errors inherit from `arcadepy.APIError`.

  ```python
  import arcadepy
  from arcadepy import Arcade

  client = Arcade()

  try:
      client.chat.completions.create(
          messages=[
              {
                  "role": "user",
                  "content": "Hello, how can I use Arcade AI?",
              }
          ],
      )
  except arcadepy.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except arcadepy.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except arcadepy.APIStatusError as e:
      print("Another non-200-range status code was received")
      print(e.status_code)
      print(e.response)
  ```

  Error codes are as followed:

  | Status Code | Error Type                 |
  | ----------- | -------------------------- |
  | 400         | `BadRequestError`          |
  | 401         | `AuthenticationError`      |
  | 403         | `PermissionDeniedError`    |
  | 404         | `NotFoundError`            |
  | 422         | `UnprocessableEntityError` |
  | 429         | `RateLimitError`           |
  | >=500       | `InternalServerError`      |
  | N/A         | `APIConnectionError`       |



  Certain errors are automatically retried 2 times by default, with a short exponential backoff.
  Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
  429 Rate Limit, and >=500 Internal errors are all retried by default.

  You can use the `max_retries` option to configure or disable retry settings:

  ```python
  from arcadepy import Arcade


  client = Arcade(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).chat.completions.create(
      messages=[
          {
              "role": "user",
              "content": "Hello, how can I use Arcade AI?",
          }
      ],
  )
  ```



  By default requests time out after 1 minute. You can configure this with a `timeout` option,
  which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/#fine-tuning-the-configuration) object:

  ```python
  from arcadepy import Arcade


  client = Arcade(
      
      timeout=20.0,
  )


  client = Arcade(
      timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
  )


  client.with_options(timeout=5.0).chat.completions.create(
      messages=[
          {
              "role": "user",
              "content": "Hello, how can I use Arcade AI?",
          }
      ],
  )
  ```

  On timeout, an `APITimeoutError` is thrown.

  Note that requests that time out are [retried twice by default](https://github.com/ArcadeAI/arcade-py/tree/main/#retries).





  We use the standard library [`logging`](https://docs.python.org/3/library/logging.html) module.

  You can enable logging by setting the environment variable `ARCADE_LOG` to `info`.

  ```shell
  $ export ARCADE_LOG=info
  ```

  Or to `debug` for more verbose logging.



  In an API response, a field may be explicitly `null`, or missing entirely; in either case, its value is `None` in this library. You can differentiate the two cases with `.model_fields_set`:

  ```py
  if response.my_field is None:
    if 'my_field' not in response.model_fields_set:
      print('Got json like {}, without a "my_field" key present at all.')
    else:
      print('Got json like {"my_field": null}.')
  ```



  The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g.,

  ```py
  from arcadepy import Arcade

  client = Arcade()
  response = client.chat.completions.with_raw_response.create(
      messages=[{
          "role": "user",
          "content": "Hello, how can I use Arcade AI?",
      }],
  )
  print(response.headers.get('X-My-Header'))

  completion = response.parse()  # get the object that `chat.completions.create()` would have returned
  print(completion.id)
  ```

  These methods return an [`APIResponse`](https://github.com/ArcadeAI/arcade-py/tree/main/src/arcadepy/_response.py) object.

  The async client returns an [`AsyncAPIResponse`](https://github.com/ArcadeAI/arcade-py/tree/main/src/arcadepy/_response.py) with the same structure, the only difference being `await`able methods for reading the response content.



  The above interface eagerly reads the full response body when you make the request, which may not always be what you want.

  To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.

  ```python
  with client.chat.completions.with_streaming_response.create(
      messages=[
          {
              "role": "user",
              "content": "Hello, how can I use Arcade AI?",
          }
      ],
  ) as response:
      print(response.headers.get("X-My-Header"))

      for line in response.iter_lines():
          print(line)
  ```

  The context manager is required so that the response will reliably be closed.



  This library is typed for convenient access to the documented API.

  If you need to access undocumented endpoints, params, or response properties, the library can still be used.



  To make requests to undocumented endpoints, you can make requests using `client.get`, `client.post`, and other
  http verbs. Options on the client will be respected (such as retries) will be respected when making this
  request.

  ```py
  import httpx

  response = client.post(
      "/foo",
      cast_to=httpx.Response,
      body={"my_param": True},
  )

  print(response.headers.get("x-foo"))
  ```



  If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` request
  options.



  To access undocumented response properties, you can access the extra fields like `response.unknown_prop`. You
  can also get all the extra fields on the Pydantic model as a dict with
  [`response.model_extra`](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel.model_extra).



  You can directly override the [httpx client](https://www.python-httpx.org/api/#client) to customize it for your use case, including:

  - Support for proxies
  - Custom transports
  - Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality

  ```python
  from arcadepy import Arcade, DefaultHttpxClient

  client = Arcade(
      
      base_url="http://my.test.server.example.com:8083",
      http_client=DefaultHttpxClient(
          proxies="http://my.test.proxy.example.com",
          transport=httpx.HTTPTransport(local_address="0.0.0.0"),
      ),
  )
  ```

  You can also customize the client on a per-request basis by using `with_options()`:

  ```python
  client.with_options(http_client=DefaultHttpxClient(...))
  ```



  By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting.



  This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:

  1. Changes that only affect static types, without breaking runtime behavior.
  2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals)_.
  3. Changes that we do not expect to impact the vast majority of users in practice.

  We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.

  We are keen for your feedback; please open an [issue](https://www.github.com/ArcadeAI/arcade-py/issues) with questions, bugs, or suggestions.



  If you've upgraded to the latest version but aren't seeing any new features you were expecting then your python environment is likely still using an older version.

  You can determine the version that is being used at runtime with:

  ```py
  import arcadepy
  print(arcadepy.__version__)
  ```



  Python 3.8 or higher.



  See [the contributing documentation](https://github.com/ArcadeAI/arcade-py/tree/main/./CONTRIBUTING.md).


pkgId: 8771bf2b2e4aa8c99fe08cf8da39b8430fe48adf63c08dbaac40cb50a047f0af
name: python-arcadeutils
arch: src
version: 0.1.11
epoch: 0
release: 1
summary: Collection of utilities written in Python for working with various arcade binaries.
url: https://github.com/DragonMinded/arcadeutils
rpm_license: Public Domain
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcadeutils-0.1.11-1.src.rpm
checksum_type: sha256
description:
  Collection of utilities written in Python for working with various arcade binaries.
  This is mostly suited towards the separated formats found in MAME archival releases
  but also work on a variety of binaries from basically anywhere. It is fully typed
  and requires a minimum of Python 3.6 to operate.



  The ByteUtil class provides a series of handy ROM manipulation functions for combining
  split ROMs and byteswapping ROMs. Use these when you are attempting to combine ROMs
  that are dumped from multiple chips but are meant to be mapped to high and low bytes
  in memory on a 16-bit or 32-bit arcade system.



  Takes a single byte argument "data", assumes that it is a 16-bit ROM where the upper and
  lower bytes have been swapped and swaps them. Returns a new bytes object of the same
  length where the upper and lower bytes of each 16-bit pair are swapped.



  Takes a single byte argument "data", assumes that it is a 32-bit ROM where each of the 32-bit
  words is swapped. Returns a new bytes object of the same length where each 32-bit chunk
  of bytes is swapped.



  Takes two byte aruments "upper" and "lower" and assumes that these represent a ROM dump from
  two 16-bit chips that are memory-mapped to a 32-bit word on the hardware they were dumped
  from. Assembles them both into a single 32-bit ROM file where each 32-bit word is made
  up of the 16-bit upper value and 16-bit lower value of the two inputs.



  Takes two byte aruments "upper" and "lower" and assumes that these represent a ROM dump from
  two 8-bit chips that are memory-mapped to a 16-bit word on the hardware they were dumped
  from. Assembles them both into a single 16-bit ROM file where each half-word is made
  up of the 8-bit upper value and 8-bit lower value of the two inputs.



  Takes a single byte argument "data", assumes that it is a 32-bit ROM and splits it into
  two 16-bit ROMs of the upper and lower halves of each 32-bit value, returning a tuple of
  the upper and lower bytes. This is the exact reciprocal of `combine16bithalves`.



  Takes a single byte argument "data", assumes that it is a 16-bit ROM and splits it into
  two 8-bit ROMs of the upper and lower halves of each 16-bit value, returning a tuple of
  the upper and lower bytes. This is the exact reciprocal of `combine8bithalves`.



  A class that can be passed an open file handle for a binary file that was opened either
  in read-only or append mode. Presents a bytearray-like interface where data can read
  or written as if it was an array in memory without loading the file into RAM. This can
  be used with any function in `BinaryDiff` that takes an argument of type bytes in order
  to minimize the memory footprint of patching on systems with limited RAM.

  In addition to the properties and methods below, you can call len() on an instance of
  FileBytes to get the length, you can index into it using array syntax, and you can add
  an instance of FileBytes or binary data to an existing FileBytes instance in order to
  append data, much like a bytes or bytearray instance.



  Returns the original handle that this FileBytes instance was constructed with. Note that
  this is read-only by design so that the handle cannot be changed out from under the
  class.



  Returns a clone of the current FileBytes instance so that the clone or original can be
  safely modified without affecting the other copy. Note that if you choose to call
  `write_changes()` on any instance of a FileBytes, all clones of that instance will
  be placed into a mode where they can only be cloned themselves to prevent surprises.



  Appends bytes or the contents of another FileBytes instance to the end of this instance.
  The data will be placed at the very end, resizing the internal representation of the file
  to fit the data. When calling `write_changes()` these bytes will be included and the file
  will be resized accordingly. Note that appending from another FileBytes will cause the
  entire file to be read before it is appended.



  Truncates the internal representation of the file to the number of bytes specified.
  This discards any data or changes applied after the truncation. When calling `write_changes()`
  the file will be resized accordingly to truncate it down.



  Takes a single bytes or FileBytes object and searches the current instance for those
  bytes. Returns the index of the first found occurence of those bytes if they are present
  or None of they are not. Note that much like `append()`, searching from another FileBytes
  will cause the entire file to be read before it is used as the search term. Optionally
  a start keyword argument can be supplied to specify an offset to start searching at.
  Optionally an end keyword argument can be supplied to specify an offset to stop searching at.



  Applies all append, truncate and update operations that were performed to the instance
  of FileBytes. The file will be updated to match the contents of FileBytes and then the
  FileBytes instance will be updated to reflect that new file. Once you call this method,
  any clones of the instance you have written changes back from will invalidate themselves
  so that you are not surprised by their contents changing out from under you.



  The BinaryDiff class provides a series of handy functions for manipulating binary data
  based on a series of hex differences. It also provides functions for creating a series
  of hex differences based on two identically-sized binaries. The format is designed to
  be human-readable.



  Given two identically-lengthed bytes arguments "bin1" and "bin2", returns a list of
  patches that would need to be applied to "bin1" to convert it to "bin2". See the below
  patch format for documentation as to what each list entry will look like. Note that in
  addition to bytes, either "bin1", "bin2" or both can be provided instead an instance of
  `FileBytes` to diff data that is not loaded into RAM.



  Given a list of patches as documented in the patch format section below, looks for a
  "File Size" special comment and returns the value found. If no such section exists in
  the list of patches it returns None.



  Given a list of patches as documented in the patch format section below, looks for a
  "Description" special comment and returns the value found. If no such section exists in
  the list of patches it returns None.



  Given a list of patches as documented in the patch format section below, examines the
  list of patches and determines the minimum length of a binary that could be patched
  by these patch bytes. Note that this ignores the "File Size" special comment and instead
  focuses on the highest address of any byte changed by any single patch line.



  Given a byte argument "binary" and a list of patches argument "patchlines", examines
  the series of patches including the "File Size" comment and returns True if the binary
  supplied could be patched by the patches supplied and False otherwise. Things that could
  make a binary ineliglbe for patching include having the wrong file size, having not enough
  bytes to patch or having incorrect bytes at a particular patch offset. If you pass in
  the optional boolean keyword argument "reverse" set to True, this function will calculate
  whether the reverse of the patch could instead be applied. If you pass in the optional
  boolean keyword argument "ignore_size_differences" then the "File Size" comment will be
  ignored. Note that in addition to bytes, the "binary" argument can be passed an instance
  of `FileBytes` in order to check a file for patch applicability without loading it into
  RAM.



  Given a byte argument "binary" and a list of patches argument "patchlines", actually
  perform the patches requested and return a new binary with the patches applied. If you
  supply the optional boolean keyword argument "reverse" set to True, this function will
  instead patch the reverse of each patch. A binary that was patched using `BinaryDiff.patch`
  can be reverted back to the original format by calling `BinaryDiff.patch` again with
  the "reverse" argument set to True. Note that the only restriction to this is if any of
  the patches include wildcards then the resulting patched binary cannot be reversed.
  If you pass in the optional boolean keyword argument "ignore_size_differences" then the
  "File Size" comment will be ignored. Note that in addition to bytes, the "binary" argument
  can be passed an instance of `FileBytes` in order to patch a file without loading it into
  RAM. If you go this route, make sure to call `FileBytes.write_changes` after calling
  `BinaryDiff.patch`.



  The patch format is simple. For each item in the patch list, the number on the left of
  the colon is the hex offset where the difference was found, and the numbers on the right
  are the hex values to find and replace. A wildcard (`*`) can be substituted for a hex
  pair for any byte in the before section if you do not care what the value is, but be
  aware that this will make the patch non-reversible. Arbitrary comments are supported
  anywhere in the list of patches. If a list entry starts with the `#` character to it will
  be seen as a comment. Special values are recognized in comments. If you create a comment
  starting with `# File size:` then the the data length will be compared against the decimal
  number placed after the colon and any file not matching that length will be rejected.
  If you create a comment starting with `# Description` then all text after the colon will
  be returned as the patch top level description.

  Some examples are as follows:

  A simple patch changing a byte in a file at offset `0x256` from `0xAA` to `0xDD`:

  ```
  256: AA -> DD
  ```

  That same patch, but only for files that are exactly 1024 bytes long:

  ```

  256: AA -> DD
  ```

  A patch that does not care about one of the bytes it is patching. The byte at `0x513`
  can be any value and the patch will still be applied, and altogether 4 bytes starting
  at `0x512` will be changed to the hex value `0x00 0x11 0x22 0x33`:

  ```
  512: AA * CC DD -> 00 11 22 33
  ```

  A patch with multiple offsets, and helpful author descriptions for each section:

  ```

  128: AA -> BB


  256: 33 -> 44
  ```


pkgId: 0a9f2fa9503dbb5de92649008dbecb0b21672323931456649bdbaef78d5ce117
name: python-arcam-fmj
arch: src
version: 1.5.2
epoch: 0
release: 1
summary: A python library for speaking to Arcam receivers
url: https://github.com/elupus/arcam_fmj
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcam-fmj-1.5.2-1.src.rpm
checksum_type: sha256
description:
  Code to set volume and source using library.
      async def run():
          host = '192.168.0.2'
          port = '50000'
          zone = 1
          volume = 50
          source = SourceCodes.PVR
          client = Client(host, port)
          async with ClientContext(client):
              state = State(client, zone)
              await state.set_volume(volume)
              await state.set_source(source)
      loop = asyncio.get_event_loop()
      loop.run_until_complete (run())


pkgId: 156bc2b8c7c7890cef3e06f6a383535fdf67c906f24dbc15c4a1993684951cdd
name: python-arcana
arch: src
version: 0.10.19
epoch: 0
release: 1
url: https://pypi.org/project/arcana/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcana-0.10.19-1.src.rpm
checksum_type: sha256
summary:
  Abstraction of Repository-Centric ANAlysis (Arcana): A rramework for analysing on file-based datasets "in-place" (i.e. without manual download)

description:
  Abstraction of Repository-Centric ANAlysis (Arcana_) is Python framework
  for "repository-centric" analyses of data tree (e.g. NeuroImaging
  studies) built on the Pydra_ dataflow engine.
  Arcana_ manages all interactions with "store" the data tree is stored in via adapter layers
  designed for specific repository software or data structures (e.g. XNAT or BIDS).
  Intermediate outputs are stored, along with the parameters used to derive them,
  back into the store for reuse by subsequent analysis steps.
  Analysis workflows are constructed and executed using the Pydra_ dataflow
  API, and can either be run locally or submitted to cloud or HPC clusters
  using Pydra_'s various execution plugins. For a requested output, Arcana determines the
  required processing steps by querying the store to check for missing intermediate
  outputs and parameter changes before constructing the required workflow graph.

rpm_license:
  Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Public License  By exercising the Licensed Rights (defined below), You accept and agree to be bound by the terms and conditions of this Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Public License ("Public License"). To the extent this Public License may be interpreted as a contract, You are granted the Licensed Rights in consideration of Your acceptance of these terms and conditions, and the Licensor grants You such rights in consideration of benefits the Licensor receives from making the Licensed Material available under these terms and conditions.  Section 1 – Definitions.  Adapted Material means material subject to Copyright and Similar Rights that is derived from or based upon the Licensed Material and in which the Licensed Material is translated, altered, arranged, transformed, or otherwise modified in a manner requiring permission under the Copyright and Similar Rights held by the Licensor. For purposes of this Public License, where the Licensed Material is a musical work, performance, or sound recording, Adapted Material is always produced where the Licensed Material is synched in timed relation with a moving image. Adapter's License means the license You apply to Your Copyright and Similar Rights in Your contributions to Adapted Material in accordance with the terms and conditions of this Public License. BY-NC-SA Compatible License means a license listed at creativecommons.org/compatiblelicenses, approved by Creative Commons as essentially the equivalent of this Public License. Copyright and Similar Rights means copyright and/or similar rights closely related to copyright including, without limitation, performance, broadcast, sound recording, and Sui Generis Database Rights, without regard to how the rights are labeled or categorized. For purposes of this Public License, the rights specified in Section 2(b)(1)-(2) are not Copyright and Similar Rights. Effective Technological Measures means those measures that, in the absence of proper authority, may not be circumvented under laws fulfilling obligations under Article 11 of the WIPO Copyright Treaty adopted on December 20, 1996, and/or similar international agreements. Exceptions and Limitations means fair use, fair dealing, and/or any other exception or limitation to Copyright and Similar Rights that applies to Your use of the Licensed Material. License Elements means the license attributes listed in the name of a Creative Commons Public License. The License Elements of this Public License are Attribution, NonCommercial, and ShareAlike. Licensed Material means the artistic or literary work, database, or other material to which the Licensor applied this Public License. Licensed Rights means the rights granted to You subject to the terms and conditions of this Public License, which are limited to all Copyright and Similar Rights that apply to Your use of the Licensed Material and that the Licensor has authority to license. Licensor means the individual(s) or entity(ies) granting rights under this Public License. NonCommercial means not primarily intended for or directed towards commercial advantage or monetary compensation. For purposes of this Public License, the exchange of the Licensed Material for other material subject to Copyright and Similar Rights by digital file-sharing or similar means is NonCommercial provided there is no payment of monetary compensation in connection with the exchange. Share means to provide material to the public by any means or process that requires permission under the Licensed Rights, such as reproduction, public display, public performance, distribution, dissemination, communication, or importation, and to make material available to the public including in ways that members of the public may access the material from a place and at a time individually chosen by them. Sui Generis Database Rights means rights other than copyright resulting from Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, as amended and/or succeeded, as well as other essentially equivalent rights anywhere in the world. You means the individual or entity exercising the Licensed Rights under this Public License. Your has a corresponding meaning.  Section 2 – Scope.  License grant. Subject to the terms and conditions of this Public License, the Licensor hereby grants You a worldwide, royalty-free, non-sublicensable, non-exclusive, irrevocable license to exercise the Licensed Rights in the Licensed Material to: reproduce and Share the Licensed Material, in whole or in part, for NonCommercial purposes only; and produce, reproduce, and Share Adapted Material for NonCommercial purposes only. Exceptions and Limitations. For the avoidance of doubt, where Exceptions and Limitations apply to Your use, this Public License does not apply, and You do not need to comply with its terms and conditions. Term. The term of this Public License is specified in Section 6(a). Media and formats; technical modifications allowed. The Licensor authorizes You to exercise the Licensed Rights in all media and formats whether now known or hereafter created, and to make technical modifications necessary to do so. The Licensor waives and/or agrees not to assert any right or authority to forbid You from making technical modifications necessary to exercise the Licensed Rights, including technical modifications necessary to circumvent Effective Technological Measures. For purposes of this Public License, simply making modifications authorized by this Section 2(a)(4) never produces Adapted Material. Downstream recipients. Offer from the Licensor – Licensed Material. Every recipient of the Licensed Material automatically receives an offer from the Licensor to exercise the Licensed Rights under the terms and conditions of this Public License. Additional offer from the Licensor – Adapted Material. Every recipient of Adapted Material from You automatically receives an offer from the Licensor to exercise the Licensed Rights in the Adapted Material under the conditions of the Adapter’s License You apply. No downstream restrictions. You may not offer or impose any additional or different terms or conditions on, or apply any Effective Technological Measures to, the Licensed Material if doing so restricts exercise of the Licensed Rights by any recipient of the Licensed Material. No endorsement. Nothing in this Public License constitutes or may be construed as permission to assert or imply that You are, or that Your use of the Licensed Material is, connected with, or sponsored, endorsed, or granted official status by, the Licensor or others designated to receive attribution as provided in Section 3(a)(1)(A)(i).  Other rights. Moral rights, such as the right of integrity, are not licensed under this Public License, nor are publicity, privacy, and/or other similar personality rights; however, to the extent possible, the Licensor waives and/or agrees not to assert any such rights held by the Licensor to the limited extent necessary to allow You to exercise the Licensed Rights, but not otherwise. Patent and trademark rights are not licensed under this Public License. To the extent possible, the Licensor waives any right to collect royalties from You for the exercise of the Licensed Rights, whether directly or through a collecting society under any voluntary or waivable statutory or compulsory licensing scheme. In all other cases the Licensor expressly reserves any right to collect such royalties, including when the Licensed Material is used other than for NonCommercial purposes.  Section 3 – License Conditions.  Your exercise of the Licensed Rights is expressly made subject to the following conditions.  Attribution.  If You Share the Licensed Material (including in modified form), You must: retain the following if it is supplied by the Licensor with the Licensed Material: identification of the creator(s) of the Licensed Material and any others designated to receive attribution, in any reasonable manner requested by the Licensor (including by pseudonym if designated); a copyright notice; a notice that refers to this Public License; a notice that refers to the disclaimer of warranties; a URI or hyperlink to the Licensed Material to the extent reasonably practicable; indicate if You modified the Licensed Material and retain an indication of any previous modifications; and indicate the Licensed Material is licensed under this Public License, and include the text of, or the URI or hyperlink to, this Public License. You may satisfy the conditions in Section 3(a)(1) in any reasonable manner based on the medium, means, and context in which You Share the Licensed Material. For example, it may be reasonable to satisfy the conditions by providing a URI or hyperlink to a resource that includes the required information. If requested by the Licensor, You must remove any of the information required by Section 3(a)(1)(A) to the extent reasonably practicable. ShareAlike.  In addition to the conditions in Section 3(a), if You Share Adapted Material You produce, the following conditions also apply. The Adapter’s License You apply must be a Creative Commons license with the same License Elements, this version or later, or a BY-NC-SA Compatible License. You must include the text of, or the URI or hyperlink to, the Adapter's License You apply. You may satisfy this condition in any reasonable manner based on the medium, means, and context in which You Share Adapted Material. You may not offer or impose any additional or different terms or conditions on, or apply any Effective Technological Measures to, Adapted Material that restrict exercise of the rights granted under the Adapter's License You apply.  Section 4 – Sui Generis Database Rights.  Where the Licensed Rights include Sui Generis Database Rights that apply to Your use of the Licensed Material:  for the avoidance of doubt, Section 2(a)(1) grants You the right to extract, reuse, reproduce, and Share all or a substantial portion of the contents of the database for NonCommercial purposes only; if You include all or a substantial portion of the database contents in a database in which You have Sui Generis Database Rights, then the database in which You have Sui Generis Database Rights (but not its individual contents) is Adapted Material, including for purposes of Section 3(b); and You must comply with the conditions in Section 3(a) if You Share all or a substantial portion of the contents of the database.  For the avoidance of doubt, this Section 4 supplements and does not replace Your obligations under this Public License where the Licensed Rights include other Copyright and Similar Rights.  Section 5 – Disclaimer of Warranties and Limitation of Liability.  Unless otherwise separately undertaken by the Licensor, to the extent possible, the Licensor offers the Licensed Material as-is and as-available, and makes no representations or warranties of any kind concerning the Licensed Material, whether express, implied, statutory, or other. This includes, without limitation, warranties of title, merchantability, fitness for a particular purpose, non-infringement, absence of latent or other defects, accuracy, or the presence or absence of errors, whether or not known or discoverable. Where disclaimers of warranties are not allowed in full or in part, this disclaimer may not apply to You. To the extent possible, in no event will the Licensor be liable to You on any legal theory (including, without limitation, negligence) or otherwise for any direct, special, indirect, incidental, consequential, punitive, exemplary, or other losses, costs, expenses, or damages arising out of this Public License or use of the Licensed Material, even if the Licensor has been advised of the possibility of such losses, costs, expenses, or damages. Where a limitation of liability is not allowed in full or in part, this limitation may not apply to You.  The disclaimer of warranties and limitation of liability provided above shall be interpreted in a manner that, to the extent possible, most closely approximates an absolute disclaimer and waiver of all liability.  Section 6 – Term and Termination.  This Public License applies for the term of the Copyright and Similar Rights licensed here. However, if You fail to comply with this Public License, then Your rights under this Public License terminate automatically.  Where Your right to use the Licensed Material has terminated under Section 6(a), it reinstates: automatically as of the date the violation is cured, provided it is cured within 30 days of Your discovery of the violation; or upon express reinstatement by the Licensor. For the avoidance of doubt, this Section 6(b) does not affect any right the Licensor may have to seek remedies for Your violations of this Public License. For the avoidance of doubt, the Licensor may also offer the Licensed Material under separate terms or conditions or stop distributing the Licensed Material at any time; however, doing so will not terminate this Public License. Sections 1, 5, 6, 7, and 8 survive termination of this Public License.  Section 7 – Other Terms and Conditions.  The Licensor shall not be bound by any additional or different terms or conditions communicated by You unless expressly agreed. Any arrangements, understandings, or agreements regarding the Licensed Material not stated herein are separate from and independent of the terms and conditions of this Public License.  Section 8 – Interpretation.  For the avoidance of doubt, this Public License does not, and shall not be interpreted to, reduce, limit, restrict, or impose conditions on any use of the Licensed Material that could lawfully be made without permission under this Public License. To the extent possible, if any provision of this Public License is deemed unenforceable, it shall be automatically reformed to the minimum extent necessary to make it enforceable. If the provision cannot be reformed, it shall be severed from this Public License without affecting the enforceability of the remaining terms and conditions. No term or condition of this Public License will be waived and no failure to comply consented to unless expressly agreed to by the Licensor. Nothing in this Public License constitutes or may be interpreted as a limitation upon, or waiver of, any privileges and immunities that apply to the Licensor or You, including from the legal processes of any jurisdiction or authority.  Creative Commons is not a party to its public licenses. Notwithstanding, Creative Commons may elect to apply one of its public licenses to material it publishes and in those instances will be considered the “Licensor.” The text of the Creative Commons public licenses is dedicated to the public domain under the CC0 Public Domain Dedication. Except for the limited purpose of indicating that material is shared under a Creative Commons public license or as otherwise permitted by the Creative Commons policies published at creativecommons.org/policies, Creative Commons does not authorize the use of the trademark “Creative Commons” or any other trademark or logo of Creative Commons without its prior written consent including, without limitation, in connection with any unauthorized modifications to any of its public licenses or any other arrangements, understandings, or agreements concerning use of licensed material. For the avoidance of doubt, this paragraph does not form part of the public licenses.  Creative Commons may be contacted at creativecommons.org.  Additional languages available: العربية, čeština, Deutsch, Ελληνικά, Español, euskara, suomeksi, français, hrvatski, Bahasa Indonesia, italiano, 日本語, 한국어, Lietuvių, latviski, te reo Māori, Nederlands, norsk, polski, português, română, русский, Slovenščina, svenska, Türkçe, українська, 中文, 華語. Please read the FAQ for more information about official translations.


pkgId: 7f27c1eba4e816e11fb745d9f966f2f65d8d912433445afde3f224d166f5d2bc
name: python-arcana-xnat
arch: src
version: 0.4.1
epoch: 0
release: 1
url: https://pypi.org/project/arcana-xnat/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcana-xnat-0.4.1-1.src.rpm
checksum_type: sha256
summary:
  An extension of the Arcana framework to apply workflows and analyses on data stored within XNAT data repositories

description:
  An extension for the Arcana_ framework that adds the following classes to allow integrated
  deployment of workflows and analysis classes with XNAT_ imaging data repositories:
  * ``Xnat`` data store for accessing data via REST API (only)
  * ``XnatViaCS`` data store for accessing data in the XNAT archive directly when running within the XNAT Container Service
  * ``XnatApp`` container image class, for building Docker images that can be installed, ready-to-go, in the XNAT Container Service

rpm_license:
  Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Public License  By exercising the Licensed Rights (defined below), You accept and agree to be bound by the terms and conditions of this Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Public License ("Public License"). To the extent this Public License may be interpreted as a contract, You are granted the Licensed Rights in consideration of Your acceptance of these terms and conditions, and the Licensor grants You such rights in consideration of benefits the Licensor receives from making the Licensed Material available under these terms and conditions.  Section 1 – Definitions.  Adapted Material means material subject to Copyright and Similar Rights that is derived from or based upon the Licensed Material and in which the Licensed Material is translated, altered, arranged, transformed, or otherwise modified in a manner requiring permission under the Copyright and Similar Rights held by the Licensor. For purposes of this Public License, where the Licensed Material is a musical work, performance, or sound recording, Adapted Material is always produced where the Licensed Material is synched in timed relation with a moving image. Adapter's License means the license You apply to Your Copyright and Similar Rights in Your contributions to Adapted Material in accordance with the terms and conditions of this Public License. BY-NC-SA Compatible License means a license listed at creativecommons.org/compatiblelicenses, approved by Creative Commons as essentially the equivalent of this Public License. Copyright and Similar Rights means copyright and/or similar rights closely related to copyright including, without limitation, performance, broadcast, sound recording, and Sui Generis Database Rights, without regard to how the rights are labeled or categorized. For purposes of this Public License, the rights specified in Section 2(b)(1)-(2) are not Copyright and Similar Rights. Effective Technological Measures means those measures that, in the absence of proper authority, may not be circumvented under laws fulfilling obligations under Article 11 of the WIPO Copyright Treaty adopted on December 20, 1996, and/or similar international agreements. Exceptions and Limitations means fair use, fair dealing, and/or any other exception or limitation to Copyright and Similar Rights that applies to Your use of the Licensed Material. License Elements means the license attributes listed in the name of a Creative Commons Public License. The License Elements of this Public License are Attribution, NonCommercial, and ShareAlike. Licensed Material means the artistic or literary work, database, or other material to which the Licensor applied this Public License. Licensed Rights means the rights granted to You subject to the terms and conditions of this Public License, which are limited to all Copyright and Similar Rights that apply to Your use of the Licensed Material and that the Licensor has authority to license. Licensor means the individual(s) or entity(ies) granting rights under this Public License. NonCommercial means not primarily intended for or directed towards commercial advantage or monetary compensation. For purposes of this Public License, the exchange of the Licensed Material for other material subject to Copyright and Similar Rights by digital file-sharing or similar means is NonCommercial provided there is no payment of monetary compensation in connection with the exchange. Share means to provide material to the public by any means or process that requires permission under the Licensed Rights, such as reproduction, public display, public performance, distribution, dissemination, communication, or importation, and to make material available to the public including in ways that members of the public may access the material from a place and at a time individually chosen by them. Sui Generis Database Rights means rights other than copyright resulting from Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, as amended and/or succeeded, as well as other essentially equivalent rights anywhere in the world. You means the individual or entity exercising the Licensed Rights under this Public License. Your has a corresponding meaning.  Section 2 – Scope.  License grant. Subject to the terms and conditions of this Public License, the Licensor hereby grants You a worldwide, royalty-free, non-sublicensable, non-exclusive, irrevocable license to exercise the Licensed Rights in the Licensed Material to: reproduce and Share the Licensed Material, in whole or in part, for NonCommercial purposes only; and produce, reproduce, and Share Adapted Material for NonCommercial purposes only. Exceptions and Limitations. For the avoidance of doubt, where Exceptions and Limitations apply to Your use, this Public License does not apply, and You do not need to comply with its terms and conditions. Term. The term of this Public License is specified in Section 6(a). Media and formats; technical modifications allowed. The Licensor authorizes You to exercise the Licensed Rights in all media and formats whether now known or hereafter created, and to make technical modifications necessary to do so. The Licensor waives and/or agrees not to assert any right or authority to forbid You from making technical modifications necessary to exercise the Licensed Rights, including technical modifications necessary to circumvent Effective Technological Measures. For purposes of this Public License, simply making modifications authorized by this Section 2(a)(4) never produces Adapted Material. Downstream recipients. Offer from the Licensor – Licensed Material. Every recipient of the Licensed Material automatically receives an offer from the Licensor to exercise the Licensed Rights under the terms and conditions of this Public License. Additional offer from the Licensor – Adapted Material. Every recipient of Adapted Material from You automatically receives an offer from the Licensor to exercise the Licensed Rights in the Adapted Material under the conditions of the Adapter’s License You apply. No downstream restrictions. You may not offer or impose any additional or different terms or conditions on, or apply any Effective Technological Measures to, the Licensed Material if doing so restricts exercise of the Licensed Rights by any recipient of the Licensed Material. No endorsement. Nothing in this Public License constitutes or may be construed as permission to assert or imply that You are, or that Your use of the Licensed Material is, connected with, or sponsored, endorsed, or granted official status by, the Licensor or others designated to receive attribution as provided in Section 3(a)(1)(A)(i).  Other rights. Moral rights, such as the right of integrity, are not licensed under this Public License, nor are publicity, privacy, and/or other similar personality rights; however, to the extent possible, the Licensor waives and/or agrees not to assert any such rights held by the Licensor to the limited extent necessary to allow You to exercise the Licensed Rights, but not otherwise. Patent and trademark rights are not licensed under this Public License. To the extent possible, the Licensor waives any right to collect royalties from You for the exercise of the Licensed Rights, whether directly or through a collecting society under any voluntary or waivable statutory or compulsory licensing scheme. In all other cases the Licensor expressly reserves any right to collect such royalties, including when the Licensed Material is used other than for NonCommercial purposes.  Section 3 – License Conditions.  Your exercise of the Licensed Rights is expressly made subject to the following conditions.  Attribution.  If You Share the Licensed Material (including in modified form), You must: retain the following if it is supplied by the Licensor with the Licensed Material: identification of the creator(s) of the Licensed Material and any others designated to receive attribution, in any reasonable manner requested by the Licensor (including by pseudonym if designated); a copyright notice; a notice that refers to this Public License; a notice that refers to the disclaimer of warranties; a URI or hyperlink to the Licensed Material to the extent reasonably practicable; indicate if You modified the Licensed Material and retain an indication of any previous modifications; and indicate the Licensed Material is licensed under this Public License, and include the text of, or the URI or hyperlink to, this Public License. You may satisfy the conditions in Section 3(a)(1) in any reasonable manner based on the medium, means, and context in which You Share the Licensed Material. For example, it may be reasonable to satisfy the conditions by providing a URI or hyperlink to a resource that includes the required information. If requested by the Licensor, You must remove any of the information required by Section 3(a)(1)(A) to the extent reasonably practicable. ShareAlike.  In addition to the conditions in Section 3(a), if You Share Adapted Material You produce, the following conditions also apply. The Adapter’s License You apply must be a Creative Commons license with the same License Elements, this version or later, or a BY-NC-SA Compatible License. You must include the text of, or the URI or hyperlink to, the Adapter's License You apply. You may satisfy this condition in any reasonable manner based on the medium, means, and context in which You Share Adapted Material. You may not offer or impose any additional or different terms or conditions on, or apply any Effective Technological Measures to, Adapted Material that restrict exercise of the rights granted under the Adapter's License You apply.  Section 4 – Sui Generis Database Rights.  Where the Licensed Rights include Sui Generis Database Rights that apply to Your use of the Licensed Material:  for the avoidance of doubt, Section 2(a)(1) grants You the right to extract, reuse, reproduce, and Share all or a substantial portion of the contents of the database for NonCommercial purposes only; if You include all or a substantial portion of the database contents in a database in which You have Sui Generis Database Rights, then the database in which You have Sui Generis Database Rights (but not its individual contents) is Adapted Material, including for purposes of Section 3(b); and You must comply with the conditions in Section 3(a) if You Share all or a substantial portion of the contents of the database.  For the avoidance of doubt, this Section 4 supplements and does not replace Your obligations under this Public License where the Licensed Rights include other Copyright and Similar Rights.  Section 5 – Disclaimer of Warranties and Limitation of Liability.  Unless otherwise separately undertaken by the Licensor, to the extent possible, the Licensor offers the Licensed Material as-is and as-available, and makes no representations or warranties of any kind concerning the Licensed Material, whether express, implied, statutory, or other. This includes, without limitation, warranties of title, merchantability, fitness for a particular purpose, non-infringement, absence of latent or other defects, accuracy, or the presence or absence of errors, whether or not known or discoverable. Where disclaimers of warranties are not allowed in full or in part, this disclaimer may not apply to You. To the extent possible, in no event will the Licensor be liable to You on any legal theory (including, without limitation, negligence) or otherwise for any direct, special, indirect, incidental, consequential, punitive, exemplary, or other losses, costs, expenses, or damages arising out of this Public License or use of the Licensed Material, even if the Licensor has been advised of the possibility of such losses, costs, expenses, or damages. Where a limitation of liability is not allowed in full or in part, this limitation may not apply to You.  The disclaimer of warranties and limitation of liability provided above shall be interpreted in a manner that, to the extent possible, most closely approximates an absolute disclaimer and waiver of all liability.  Section 6 – Term and Termination.  This Public License applies for the term of the Copyright and Similar Rights licensed here. However, if You fail to comply with this Public License, then Your rights under this Public License terminate automatically.  Where Your right to use the Licensed Material has terminated under Section 6(a), it reinstates: automatically as of the date the violation is cured, provided it is cured within 30 days of Your discovery of the violation; or upon express reinstatement by the Licensor. For the avoidance of doubt, this Section 6(b) does not affect any right the Licensor may have to seek remedies for Your violations of this Public License. For the avoidance of doubt, the Licensor may also offer the Licensed Material under separate terms or conditions or stop distributing the Licensed Material at any time; however, doing so will not terminate this Public License. Sections 1, 5, 6, 7, and 8 survive termination of this Public License.  Section 7 – Other Terms and Conditions.  The Licensor shall not be bound by any additional or different terms or conditions communicated by You unless expressly agreed. Any arrangements, understandings, or agreements regarding the Licensed Material not stated herein are separate from and independent of the terms and conditions of this Public License.  Section 8 – Interpretation.  For the avoidance of doubt, this Public License does not, and shall not be interpreted to, reduce, limit, restrict, or impose conditions on any use of the Licensed Material that could lawfully be made without permission under this Public License. To the extent possible, if any provision of this Public License is deemed unenforceable, it shall be automatically reformed to the minimum extent necessary to make it enforceable. If the provision cannot be reformed, it shall be severed from this Public License without affecting the enforceability of the remaining terms and conditions. No term or condition of this Public License will be waived and no failure to comply consented to unless expressly agreed to by the Licensor. Nothing in this Public License constitutes or may be interpreted as a limitation upon, or waiver of, any privileges and immunities that apply to the Licensor or You, including from the legal processes of any jurisdiction or authority.  Creative Commons is not a party to its public licenses. Notwithstanding, Creative Commons may elect to apply one of its public licenses to material it publishes and in those instances will be considered the “Licensor.” The text of the Creative Commons public licenses is dedicated to the public domain under the CC0 Public Domain Dedication. Except for the limited purpose of indicating that material is shared under a Creative Commons public license or as otherwise permitted by the Creative Commons policies published at creativecommons.org/policies, Creative Commons does not authorize the use of the trademark “Creative Commons” or any other trademark or logo of Creative Commons without its prior written consent including, without limitation, in connection with any unauthorized modifications to any of its public licenses or any other arrangements, understandings, or agreements concerning use of licensed material. For the avoidance of doubt, this paragraph does not form part of the public licenses.  Creative Commons may be contacted at creativecommons.org.  Additional languages available: العربية, čeština, Deutsch, Ελληνικά, Español, euskara, suomeksi, français, hrvatski, Bahasa Indonesia, italiano, 日本語, 한국어, Lietuvių, latviski, te reo Māori, Nederlands, norsk, polski, português, română, русский, Slovenščina, svenska, Türkçe, українська, 中文, 華語. Please read the FAQ for more information about official translations.


pkgId: 6ccb90dae2224b48eae6c0f03b8af24470217a0fa9fb28c3db7e382763236b2b
name: python-arcane-bing
arch: src
version: 0.4.4
epoch: 0
release: 1
summary: Helpers to request bing API
url: https://pypi.org/project/arcane-bing/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcane-bing-0.4.4-1.src.rpm
checksum_type: sha256
description:
  This package is based on [bingads](https://docs.microsoft.com/en-us/advertising/guides/request-download-report?view=bingads-13).



  ```sh
  pip install arcane-bing
  ```





  ```python
  bing_client = Client(
      credentials=Config.BING_ADS_CREDENTIALS,
      secrets_bucket=Config.SECRETS_BUCKET,
      refresh_token_location=Config.BING_ADS_REFRESH_TOKEN,
      storage_client=storage_client
  )

  reporting_service_manager, reporting_service = bing_client.get_bing_ads_api_client()

  report_request = build_campaigns_report(reporting_service, bing_account_id)

  result_file_path = bing_client.submit_and_download(report_request, reporting_service_manager)
  ```



  :warning: For some API methods, you must provide the client's account id and the manager's customer id

  ```python
  from arcane.bing import Client
  from arcane.bing.helpers import parse_webfault_errors, parse_bing_response


  bing_client = Client(
      credentials=Config.BING_ADS_CREDENTIALS,
      secrets_bucket=Config.SECRETS_BUCKET,
      refresh_token_location=Config.BING_ADS_REFRESH_TOKEN,
      storage_client=storage_client,
      customer_id=CUSTOMER_ID,
      account_id=ACCOUNT_ID
  )

  campaign_service = bing_client.get_service_client(service_name='CampaignManagement')

  try:
      response = campaign_service.GetCampaignsByAccountId(AccountId=ACCOUNT_ID)
      all_campaigns = parse_bing_response(response)['Campaign']
      
  except WebFault as e:
      bing_error = parse_webfault_errors(e)
      
  ```


pkgId: 09a88ce1f0832da7fba695912195ffe84c4ccb4b334f195749553e41678a6c3a
name: python-arcane-datastore
arch: src
version: 1.1.10
epoch: 0
release: 1
summary: Override datastore client
url: https://pypi.org/project/arcane-datastore/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcane-datastore-1.1.10-1.src.rpm
checksum_type: sha256
description:
  This package is based on [google-cloud-datastore](https://pypi.org/project/google-cloud-datastore/).



  ```sh
  pip install arcane-datastore
  ```



  ```python
  from arcane import datastore
  client = datastore.Client()

  entity = client.get_entity('kind-id-here', 1)
  ```

  or

  ```python
  from arcane import datastore


  from configure import Config

  client = datastore.Client.from_service_account_json(Config.KEY, project=Config.GCP_PROJECT)

  entity = client.get_entity('kind-id-here', 1)
  ```


pkgId: f0a5bc32d4b0095c68e3560273282464fd7f87fe7f4c53f9caa4f8811ba8a6fa
name: python-arcane-engine
arch: src
version: 1.12.1
epoch: 0
release: 1
summary: Python SDK for Arcane Engine, a text-to-task automation platform.
url: https://github.com/arc-eng/kit
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcane-engine-1.12.1-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
  <img src="https://avatars.githubusercontent.com/ml/17635?s=140&v=" width="100" alt="Arcane Engine Logo">
  </div>

  <p align="center">
    <a href="https://github.com/apps/arcane-engine/installations/new"><b>Install</b></a> |
    <a href="https://docs.arcane.engineer">Documentation</a> |
    <a href="https://arcane.engineer/">Website</a>
  </p>



  Welcome to the development kit for **[Arcane Engine](https://arcane.engineer/engine)**, a platform that enables developers to create agentic workflows easily.

  This project contains the official Python SDK.



  Install the Python SDK using pip:

  ```bash
  pip install arcane-engine
  ```

  Use the `ArcaneEngine` class to create tasks and interact with the engine. Here's an example of how to create a task and wait for the result:

  ```python
  from arcane.engine import ArcaneEngine
  from arcane.util import wait_for_result

  engine = ArcaneEngine()
  task = engine.create_task("arc-eng/kit", "Summarize the README file and create a Github issue with the result.")
  result = wait_for_result(task)
  print(f"Task completed. Result:\n\n{task.result}")
  ```


pkgId: 6fd85b7f7330ec8dea3751ca6dfe41b74ca14866792e270b06fb9843ed780f51
name: python-arcane-flask
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Utility functions for flask apps.
url: https://pypi.org/project/arcane-flask/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcane-flask-2.0.0-1.src.rpm
checksum_type: sha256
description:
  This package help us authenticate users



  ```sh
  pip install arcane-flask
  ```



  ```python
  from arcane import flask

  @check_access_rights(service='function', required_rights='Viewer',
                       receive_rights_per_client=True, project=Config.Project, adscale_key=Config.Key)
  def function(params):
      pass

  ```


pkgId: 9af92c1e622525bb45089128486516f91865f5fe86442aaf1093e92b68300c9e
name: python-arcane-pubsub
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Override pubsub client
url: https://pypi.org/project/arcane-pubsub/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcane-pubsub-1.2.0-1.src.rpm
checksum_type: sha256
description:
  This package is base on [google-cloud-pubsub](https://pypi.org/project/google-cloud-pubsub/).



  ```sh
  pip install arcane-pubsub
  ```



  ```python
  from arcane import pubsub


  from configure import Config

  client = pubsub.Client(Config.KEY)

  client.push_to_topic('project', 'topic', {"parameter": "value"})
  ```

  Publish with a new schema

  ```python
  result = pubsub_client.publish_with_schema(
      project='my-project',
      topic_name='my-topic-with-schema',
      message=message,
      await_response=True,
  )

  ```


pkgId: fbcb02306394a9e4a85ab423bbbde9f9c5eceb120e7784ea050b8db0570fa73e
name: python-arcane-tasks
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Override tasks client
url: https://pypi.org/project/arcane-tasks/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcane-tasks-0.6.0-1.src.rpm
checksum_type: sha256
description:
  This package is base on [google-cloud-cloudtasks](https://pypi.org/project/google-cloud-tasks/).



  ```sh
  pip install arcane-tasks



  ```python
  from arcane import tasks


  from configure import Config

  tasks_client = tasks.Client(adscale_key=Config.KEY, project=Config.GCP_PROJECT)
  body = {
      'attribute' : value
  }
  task_name = "My task"
  tasks_client.publish_task(
      queue=<your-queue>,
      url=<url-to-triger>,
      body=body,
      task_name=task_name
  )
  ```


pkgId: 278a49996cc0af1cbd395553b0ad8cac88148479a0e31612543f2fff2391678d
name: python-arcane-viewer
arch: src
version: 1.0.7
epoch: 0
release: 1
url: https://github.com/PhrozenIO/Arcane
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcane-viewer-1.0.7-1.src.rpm
checksum_type: sha256
summary:
  A secure remote desktop application for Windows with the particularity of having a server entirely written in PowerShell and a cross-platform client (Python/QT6)

description:
  ![HackTheBox Meetup France](https://raw.githubusercontent.com/PhrozenIO/Arcane/main/resources/images/htb_france.png)
  <p align="center">
      I’m dedicating this project to the amazing HackTheBox France Meetup community! 🇫🇷
  </p>


pkgId: 7c0076b7abf0dcf5fdd5db6951b7e41886f7de071e623a5929169298905cd44d
name: python-arcee-py
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/arcee-py/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcee-py-2.0.1-1.src.rpm
checksum_type: sha256
description:
  > The Arcee Python client allows you to manage CPT, SFT, DPO, and Merge models on the Arcee Platform.

  This client may be used as a CLI by invoking `arcee` from the terminal, or as an SDK for programmatic use by `import arcee` in Python.

  Learn more at https://docs.arcee.ai



  ```
  pip install --upgrade arcee-py
  ```



  Your Arcee API key is obtained at https://app.arcee.ai

  In bash:

  ```
  export ARCEE_API_KEY=********
  ```

  In notebook:

  ```
  import os
  os.environ["ARCEE_API_KEY"] = "********"
  ```

  (Optional) To customize the URL of the Arcee platform:

  ```
  export ARCEE_API_URL="https://your-url.arcee.ai"
  ```

  (Optional) To specify an organization to issue requests for:

  ```
  export ARCEE_ORG="my-organization"
  ```

  If you do not specify an organization, your default organization will be used. You can change the default in your Arcee account settings.



  Upload context for retriever training:

  ```
  import arcee
  arcee.upload_docs("pubmed", docs=[{"doc_name": "doc1", "doc_text": "foo"}, {"doc_name": "doc2", "doc_text": "bar"}])
  ```





  ```
  arcee.upload_instructions_from_csv(
    "finetuning-dataset-name",
    csv_path="./your_data.csv",
    prompt_column="prompt",
    completion_column="completion"
  )
  ```



  NOTE: you will need to set `HUGGINGFACE_TOKEN` in your environment to use this function.


  ```
  arcee.api.upload_hugging_face_dataset_qa_pairs(
      "my_qa_pairs",
      hf_dataset_id="org/dataset",
      dataset_split="train",
      data_format="chatml"
  )
  ```



  You can easily train and use your Domain-Adapted Language Model (DALM) with Arcee using the CLI. Follow these steps post installation to train and utilize your DALM:



  Upload a context file for your DALM like,
  ```shell
  arcee upload context pubmed --file doc1
  ```
  Upload all files in a directory like,
  ```shell
  arcee upload context pubmed --directory docs
  ```
  Upload any combination of files and directories with,
  ```shell
  arcee upload context pubmed --directory some_docs --file doc1 --directory more_docs --file doc2
  ```
  *Note: The upload command ensures only valid and unique files are uploaded.*


  Train your DALM with any uploaded context like,
  ```shell
  arcee train medical_dalm --context pubmed

  ```

  Generate text completions from a model like,
   ```shell
  arcee generate medical_dalm --query "Can AI-driven music therapy contribute to the rehabilitation of patients with disorders of consciousness?"
  ```


  Retrieve documents for a given query and to view them or plug into a different LLM like,
  ```shell
  arcee retrieve medical_dalm --query "Can AI-driven music therapy contribute to the rehabilitation of patients with disorders of consciousness?"
  ```



  We use `invoke` to manage this repo. You don't need to use it, but it simplifies the workflow.

  ```shell
  git clone https://github.com/arcee-ai/arcee-python && cd arcee-python

  python -m venv .venv && source .venv/bin/activate

  pip install invoke
  inv install
  ```


  ```shell
  inv format  # run black and ruff
  inv lint    # black check, ruff check, mypy
  inv test    # pytest
  ```


  We publish in this repo by creating a new release/tag in github. On release, a github action will
  publish the `__version__` of arcee-py that is in `arcee/__init__.py`

  **So you need to increase that version before releasing, otherwise it will fail**


  1. Open a PR increasing the `__version__` of arcee-py. You can manually edit it or run `inv version`
  2. Create a new release, with the name being the `__version__` of arcee-py



  We do not recommend this. If you need to, please make the version number an alpha or beta release.<br>
  If you need to create a manual release, you can run `inv build && inv publish`


pkgId: 3df5d68ec7d33608151b7fe6c1b0787eef3306fc7eba3733325d95608b5d9ca8
name: python-arcface
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: ArcFace face recognition implementation in Tensorflow Lite.
url: https://github.com/mobilesec/arcface-tensorflowlite
rpm_license: European Union Public Licence 1.2 (EUPL 1.2)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcface-0.0.8-1.src.rpm
checksum_type: sha256
description:
  Implementation of the [ArcFace face recognition algorithm](https://openaccess.thecvf.com/content_CVPR_2019/html/Deng_ArcFace_Additive_Angular_Margin_Loss_for_Deep_Face_Recognition_CVPR_2019_paper.htm). It includes a pre-trained model based on [ResNet50](https://arxiv.org/abs/1512.03385).

  The code is based on [peteryuX's](https://github.com/peteryuX/arcface-tf2) implementation. Instead of using full Tensorflow for the inference, the model has been converted to a Tensorflow lite model using `tf.lite.TFLiteConverter` which increased the speed of the inference by a factor of ~2.27.


  You can install the package through pip:
  ```
  pip install arcface
  ```



  The following example illustrates the ease of use of this package:
  ```python
  >>> from arcface import ArcFace
  >>> face_rec = ArcFace.ArcFace()
  >>> emb1 = face_rec.calc_emb("~/Downloads/test.jpg")
  >>> print(emb1)
  array([-1.70827676e-02, -2.69084200e-02, -5.85994311e-02,  3.33652040e-03,
          9.58345132e-04,  1.21807214e-02, -6.81217164e-02, -1.33364811e-03,
         -2.12905575e-02,  1.67165045e-02,  3.52908894e-02, -5.26051633e-02,
  	   ...
         -2.11241804e-02,  2.22553015e-02, -5.71946353e-02, -2.33468022e-02],
        dtype=float32)
  >>> emb2 = face_rec.calc_emb("~/Downloads/test2.jpg")
  >>> face_rec.get_distance_embeddings(emb1, emb2)
  0.78542
  ```
  You can feed the `calc_emb` function either a single image or an array of images. Furthermore, you can supply the image as (absolute or relative) path, or an cv2-image. To make it more clear, hear are the four possibilities:

  1. (Absolute or relative) path to a single image: `face_rec.calc_emb("test.jpg")`
  2. Array of images: `face_rec.calc_emb(["test1.jpg", "test2.png"])`
  3. Single cv2-image: `face_rec.calc_emb(cv2.imread("test.png"))`
  4. Array of cv2-images: `face_rec.calc_emb([cv2.imread("test1.jpg"), cv2.imread("test2.png")])`

  The face recognition tool returns (an array of) 512-d embedding(s) as a numpy array.

  > Notice! This package does neither perform face detection nor face alignment! It assumes that the images are already pre-processsed!



  | Model | Backbone | Framework | LFW Accuracy | Speed [ms/embedding] * |
  |----------|------|------|-----|-----|
  | [ArcFace paper](https://openaccess.thecvf.com/content_CVPR_2019/html/Deng_ArcFace_Additive_Angular_Margin_Loss_for_Deep_Face_Recognition_CVPR_2019_paper.htm) | R100     | MXNet        | 99.82        | -       |
  | [ArcFace TF2](https://github.com/peteryuX/arcface-tf2)   | R50      | Tensorflow 2 | 99.35 | 102 |
  | **This repository** | **R50** | **Tensorflow Lite** | **96.87** | **45** |

  \* executed on a CPU: Intel i7-10510U



  Licensed under the EUPL, Version 1.2 or – as soon they will be approved by the European Commission - subsequent versions of the EUPL (the "Licence"). You may not use this work except in compliance with the Licence.

  **License**: [European Union Public License v1.2](https://joinup.ec.europa.eu/software/page/eupl)


pkgId: aee95b4e44460b94b640d23850b364b908d37f77dfc177ae487a1e0cf84bce3a
name: python-arcgen-python
arch: src
version: 2024.1.0
epoch: 0
release: 1
summary: Arc-length Response Corridor Generation
url: https://github.com/IMMC-UWaterloo/ARCGen-Python
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcgen-python-2024.1.0-1.src.rpm
checksum_type: sha256
description:
  ![ARCGen Logo](./Assets/ARCGen.svg)


  > [!NOTE]
  > ARCGen-Python is a port of the original [ARCGen for MATLAB](https://github.com/IMMC-UWaterloo/ARCGen). The python version of ACRGen is not updated as regularly as as MATLAB source code.

  ARCGen is a general, robust methodology providing feature-based assessment of average response and variability in the form of a characteristic average response and statistical response corridors. In particular, ARCGen is well suited to tackling the challenging types of signals common in biomechanics, such as:
  - Monotonic signals that do not share a common termination point
  - Highly oscillatory signals, such as those that capture head or limb kinematics
  - Hysteretic signals or signals that are non-monotonic in both axes

  ARCGen is released under the open-sourced GNU GPL v3 license. No warranty or guarantee of support is provided. The authors hold no responsibility for the validity, accuracy, or applicability of any results obtained from this code.



  ARCGen-Python is available for Python 3.10+ and is installed directly fron PyPI as follows :

  ``` pip install arcgen-python```



  ARCGen is used by calling the ```arcgen()``` function within a python script, as follows. ARCGen has one required input parameter (```inputData```) and a host of optional keyword arguments that provide important control over arc-length re-parameterization and signal registration. An example of ARCGen used in code with typical name-value pair arguments is provided below.

  ```python
  charAvg, innCorr, outCorr, processed, debug = arcgen(
      inputData,
      nResamplePoints=250,
      CorridorRes=250,
      nWarpCtrlPts=2,
      WarpingPenalty=1e-2,
  )
  ```
  Complete documentation of all of ARCGen's input arguments and outputs is available below and in the code. Several example cases are provided in the [`ExampleCasesAndDatasets` folder of this repository](https://github.com/IMMC-UWaterloo/ARCGen-Python/tree/main/ExampleCasesAndDatasets).



  `inputData`: Contains the signals from which a characteristic average and corridors can be computed. Signals must be two-dimensional (i.e. acceleration-time, force-displacement) but do not need to contain the same number of points or be sampled at the same sampling frequency. There is no limit to the number of input signals ARCGen can accommodate, but runtime will increase as the number of signals increases. `inputSignals` must be defined in one of the following three formats.
  - a string of the path to a CSV file containing all signals stacked columnwise.
  - A list of np.ndarrays, where each entry of the list is a two-column ndarray containing signal points
  - A list of dictionaries, where each entry is a dictionary containing the signal points and a signal identifier. Dictionary format is {'data': np.ndarray, 'specId': str}, where 'data' is a two-column array of signal points and str is a string used as the signal identifier.

  The remaining parameters are optional and have defined default values in 'arcgen()' if not used.

  `nResamplePoints`: An integer defining the number of points re-parameterized signals will contain. Increasing this value will provide a smoother characteristic average and corridors. Default: 250.

  `CorridorRes`: An integer defining the number of grid points the marching squares algorithm uses to extract the corridor. This sampling grid is automatically calculated based on the most extreme possible corridor values. Increasing this value will improve how accurately the corridor is extracted. Default: 250.

  `NormalizeSignals`: A character array used to control whether magnitude normalization is performed before arc-length re-parameterization. It is highly recommended that this option is enabled. Input options: 'on' (default), 'off'

  `EllipseKFact`: A float used to scale the size of the ellipses defined by the confidence region at each point of the characteristic average. A value of 1.0 creates a corridor that is one standard deviation wide at each point of the characteristic average. Default: 1.0 (or corridors of plus and minus one standard deviation).

  `MinCorridorWidth`: A float value used to enforce a minimum corridor width based on maximum standard deviation. This option can be useful if corridors do not extend to the beginning or end of the characteristic average due to low variability between input signals. However, enforcing a minimum width is not representative of the actual variability of underlying data. Default: 0.0 (does not enforce a minimum corridor width).

  `nWarpCtrlPts`: An integer defining the number of interior control points used for signal registration. A value of 0 disables signal registration. Default: 2 (some warping).

  `WarpingPenalty`: A float defining the penalty factor used during signal registration. Default: 1e-2.

  `Diagnostics`: A character array used to activate diagnostic plots. Useful for tracing anomalous behaviours. Options: 'off' (default), 'on', 'detailed'.

  `resultsToFile`: A boolean flag indicating if `arcgen()` should print results to file. If `True`, `arcgen()` will output the characteristic average and corridors to a csv file in a folder called 'outputs' in the current working directory. `arcgen()` will also output a plot of the inputsignals superimposed with the characteristic average and corridors in the same directory. Default: `False`


  `charAvg`: A two-column array containing the computed characteristic average

  `innerCorr`: A two-column array defining the inner or lower portion of the corridor

  `outerCorr`: A two-column array defining the outer or upper portion of the corridor

  `processedSignals`: Contains information about processed signals. Formatted as a list of dictionaries, where each each signal has its own entry in the list and its own dictionary. All dictionaries are defined as {'data': np.ndarray, 'specId': str, 'xMax': float,'xMin': float, 'yMax': float, 'yMin': float, 'maxAlen': float, 'resampled': np.ndarray, 'warpControlPoints': np.ndarray}.
  - data: Four column array contianing original x,y data (cols 0,1), computed arc-length (col 2) and normalized arc-length (col 3)
  - specId: signal identifer
  - *Max, *Min: maximum and minimum (x,y) values of each signal.
  - maxAlen: total normalized arc-length of the signal
  - 'resampled': Three column array of the re-parameterized, registered signal. Col 0: normalized arc-length, Col 1, 2: x,y data
  - warpControlPoints': Two column array of control points used during signal registration

  `debug`: Dictionary containing information potential useful for debugging. Dictionary is defined as {'charAvg': np.ndarray, 'stDev': np.ndarray, 'preWarpCorrArray': np.ndarray, 'preWarpMeanCorr': float, 'warpedCorrArray': np.ndarray, warpedMeanCorrScore': float} where
  - charAvg: Two column array of the characteristic average (repeated from first positional output)
  - stDev: two column array containing the standard devation in x and y for each corresponding point in the characteristic average
  - preWarpCorrArray: x and y correlation scores prior to performing signal registration
  - preWarpmeanCorr: mean correlation score prior to peforming signal registration
  - warpedCorrArray: x and y correlation scores after performing signal registration
  - warpedMeanCorrScore: mean correlation score after performing signal registration




  If you use ARCGen-Python in published research, please use the following citation in your research.

  Hartlen D.C. and Cronin D.S. (2022), "Arc-Length Re-Parametrization and Signal Registration to Determine a Characteristic Average and Statistical Response Corridors of Biomechanical Data." *Frontiers in Bioengineering and Biotechnology* 10:843148. doi: 10.3389/fbioe.2022.843148

  Bibtex format:
  ```
  @article{Hartlen_Cronin_2022,
    AUTHOR={Hartlen, Devon C. and Cronin, Duane S.},
    TITLE={Arc-Length Re-Parametrization and Signal Registration to Determine a Characteristic Average and Statistical Response Corridors of Biomechanical Data},
    JOURNAL={Frontiers in Bioengineering and Biotechnology},
    VOLUME={10},
    YEAR={2022},
    URL={https://www.frontiersin.org/article/10.3389/fbioe.2022.843148},
    DOI={10.3389/fbioe.2022.843148},
    ISSN={2296-4185},
  }
  ```


  If you find discover any bugs or issues, or would like to suggest improvements, please create an [issue on this github repostiory](https://github.com/DCHartlen/ARCGen-Python/issues). You are invited free to submit pull requests to integrate fixes and features directly into ARCGen, although pull requests will be reviewed before integration.

  Anyone is free to fork ARCGen for thier own work, so long as you follow the requirements of the GNU GPL v3 license.



  For a detailed description of how ARCGen operates, please refer to [Hartlen and Cronin (2022)](https://www.frontiersin.org/article/10.3389/fbioe.2022.843148). Therefore, only a high-level overview is presented here. In general, the operation of ARCGen can be divided into three stages: arc-length re-parameterization, signal registration, and statistical analysis.


  Arc-length re-parameterization allows ARCGen to handle input signals that are non-monotonic in either measurement axis (a behaviour called hysteresis). Arc-length provides a convenient means to define input points with respect to a strictly monotonic value inherently tied to the shape of the signal.

  Before computing the arc-length of each curve, all signals are scaled to eliminate issues of differing magnitude between the axes. Scaling ensures that the shape of the resulting average and corridors are reflective of the inputted signals. All signals are scaled based on the mean extreme values of both measurement axes to eliminate magnitude differences between axes when calculating arc-length. These scaled values are only used for arc-length calculations and are not used later in signal registration or statistical analysis.

  Once signals have been scaled, the arc-length of each signal is computed for each point in the signal. The arc-length is then normalized to the total arc-length of each signal, such that all signals have a normalized arc-length of 1.0. Finally, signals are resampled such that all signals have points at the same normalized arc-lengths.


  One of the underlying assumptions of arc-length re-parametrization is that critical features in the signal appear at approximately the same normalized arc-length. However, the resulting characteristic average can be distorted if said features are not perfectly aligned. Additionally, features such as significant variability or noise can dramatically affect the arc-length calculation, changing where critical features occur with respect to normalized arc-length.

  Signal registration is applied to help align critical features of signals. This process introduces a warping function for each input signal that subtly alters how each signal is resampled with respect to arc-length to align critical features. These warping functions (strictly monotonic, piecewise Hermite cubic splines) are determined for all signals simultaneously by maximizing cross-correlation between all signals. To ensure that warping functions do not produce highly skewed, unrealistic responses, a penalty function is used to limit the amount of warping introduced.

  Signal registration is an optional process and is not needed if input signals are very highly correlated or strictly monotonic. While some experimentation is needed to select the best number of control points, a rule of thumb would be to set the number of interior control points to the number of inflection points expected in the characteristic average.


  Following arc-length re-parameterization and registration, all input signals will have the same number of points and have features aligned with respect to a consistent normalized arc-length. Statistical analysis is undertaken in a point-wise fashion at each normalized arc-length. This analysis assumes points are uncorrelated and distributed according to a two-dimensional normal distribution. Based on this assumption, an elliptical confidence region can be constructed at each normalized arc-length. The length of these ellipses' major and minor axes is proportional to the standard deviation at each arc-length.

  The characteristic average of the input signals is defined as the mean value at each normalized arc-length. The response corridors are the envelope of all ellipses. As there is no closed-form way of extracting this envelope, a marching-squares algorithm is used to extract this envelope numerically. Because the envelope is extracted numerically, it is important that the number of resampling points (`nResamplePoints`) is large enough to ensure that ellipses are sufficiently overlapped to provide a smooth, realistic envelope. Similarly, the resolution of the marching squares grid (`CorridorRes`) should be fine enough to capture the shape of the ellipses correctly. This last feature is similar to ensuring that the mesh of a finite element or computational fluid dynamics simulation is fine enough to resolve features.




  Version 2024.1.0 of ARCGen-python sees incremental improvement over previous versions. ARCGen-python 2024.1.0 now performs signal registration with 2 control points by default if `nWarpCtrlPts` is not otherwise defined. These changes do not change any of the underlying behaviour of ARCGen, but are intended to ensure new users get better results more quickly.

  Additionally, the `README.md` has been updated to increase clarity and get new users up and running more quickly.

   - `nWarpCtrlPts` default value changed to 2 from 0 (signal registration disabled)


  Important fix to `polygonFunction.polyxpoly()` as well as fixes to unit tests.


  This is the first production release of ARCGen-Python. There will inevitably be bugs. If you discover any throughout the course of your usage of ARCGen-Python, [please open an issue ticket](https://github.com/IMMC-UWaterloo/ARCGen-Python/issues).

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


pkgId: 390c565618dc605922df8ba2c9907b2bf04d282e2ff0ba63e4385862b54fbcbb
name: python-arcgis2geojson
arch: src
version: 3.0.3
epoch: 0
release: 1
summary: A Python library for converting ArcGIS JSON to GeoJSON
url: https://github.com/chris48s/arcgis2geojson
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcgis2geojson-3.0.3-1.src.rpm
checksum_type: sha256
description:
  [![Run tests](https://github.com/chris48s/arcgis2geojson/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/chris48s/arcgis2geojson/actions/workflows/test.yml)
  [![codecov](https://codecov.io/gh/chris48s/arcgis2geojson/branch/master/graph/badge.svg?token=uMbOfMCHqD)](https://codecov.io/gh/chris48s/arcgis2geojson)
  ![PyPI Version](https://img.shields.io/pypi/v/arcgis2geojson.svg)
  ![License](https://img.shields.io/pypi/l/arcgis2geojson.svg)
  ![Python Compatibility](https://img.shields.io/badge/dynamic/json?query=info.requires_python&label=python&url=https%3A%2F%2Fpypi.org%2Fpypi%2Farcgis2geojson%2Fjson)
  ![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)


  A Python library for converting ArcGIS JSON to GeoJSON: A partial port of ESRI's [arcgis-to-geojson-utils](https://github.com/Esri/arcgis-to-geojson-utils/).


  ```
  pip install arcgis2geojson
  ```





  Convert an ArcGIS JSON string to a GeoJSON string

  ```py
  >>> from arcgis2geojson import arcgis2geojson

  >>> input = """{
  ...     "attributes": {"OBJECTID": 123},
  ...     "geometry": {   "rings": [   [   [41.8359375, 71.015625],
  ...                                      [56.953125, 33.75],
  ...                                      [21.796875, 36.5625],
  ...                                      [41.8359375, 71.015625]]],
  ...                     "spatialReference": {"wkid": 4326}}}"""
  >>> output = arcgis2geojson(input)

  >>> output
  '{"type": "Feature", "geometry": {"type": "Polygon", "coordinates": [[[41.8359375, 71.015625], [21.796875, 36.5625], [56.953125, 33.75], [41.8359375, 71.015625]]]}, "properties": {"OBJECTID": 123}, "id": 123}'

  >>> type(output)
  <class 'str'>
  ```

  Convert a python dict to a python dict

  ```py
  >>> from arcgis2geojson import arcgis2geojson

  >>> input = {
  ...     'attributes': {'OBJECTID': 123},
  ...     'geometry': {   'rings': [   [   [41.8359375, 71.015625],
  ...                                      [56.953125, 33.75],
  ...                                      [21.796875, 36.5625],
  ...                                      [41.8359375, 71.015625]]],
  ...                     'spatialReference': {'wkid': 4326}}}
  >>> output = arcgis2geojson(input)

  >>> output
  {'type': 'Feature', 'geometry': {'type': 'Polygon', 'coordinates': [[[41.8359375, 71.015625], [21.796875, 36.5625], [56.953125, 33.75], [41.8359375, 71.015625]]]}, 'properties': {'OBJECTID': 123}, 'id': 123}

  >>> type(output)
  <class 'dict'>
  ```



  ```sh

  $ arcgis2geojson arcgis.json > geo.json


  $ curl "https://myserver.com/arcgis.json" | arcgis2geojson
  ```




  arcgis2geojson is a derivative work of ESRI's [arcgis-to-geojson-utils](https://github.com/Esri/arcgis-to-geojson-utils/). Original code is Copyright 2015 by Esri and was licensed under [the Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0).

  arcgis2geojson is made available under the MIT License.


pkgId: b5a2b2ae7b353bc4239a7d000ac16b7443afc0378a30b84aa13dcbb3f6751bc1
name: python-archABM
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Agent based simulation for architectural spaces
url: https://github.com/Vicomtech/ArchABM
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archABM-0.4.1-1.src.rpm
checksum_type: sha256
description:
  **Disclaimer**: archABM is an evolving research tool designed to familiarize the interested user with factors influencing the potential indoor airborne transmission of viruses (such as SARS-CoV-2) and the generation of carbon-dioxide (CO2) indoors.
  Calculations of virus and CO2 levels within ArchABM are based on recently published aerosol models [1,2], which however have not been validated in the context of agent-based modeling (ABM) yet. We note that uncertainty in and intrinsic variability of model parameters as well as underlying assumptions concerning model parameters may lead to errors regarding the simulated results.
  Use of archABM is the sole responsibility of the user. It is being made available without guarantee or warranty of any kind. The authors do not accept any liability from its use.
  [1] *Peng, Zhe, and Jose L. Jimenez. "Exhaled CO2 as a COVID-19 infection risk proxy for different indoor environments and activities." Environmental Science & Technology Letters 8.5 (2021): 392-397.*


pkgId: 8334a517cdf184471b42402659b00a3a88b09aa305c47a959834ad19c7541844
name: python-archadeptcli
arch: src
version: 1.2.2
epoch: 0
release: 1
url: https://archadept.com/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archadeptcli-1.2.2-1.src.rpm
checksum_type: sha256
summary:
  Command line interface for building, running, debugging, and disassembling the ArchAdept training course example projects.

description:
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/archadeptcli?logo=python&logoColor=white&style=for-the-badge)](https://pypi.org/project/archadept-cli)
  [![PyPI](https://img.shields.io/pypi/v/archadeptcli?logo=pypi&color=green&logoColor=white&style=for-the-badge)](https://pypi.org/project/archadeptcli)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/ArchAdept/archadeptcli?logo=github&color=orange&logoColor=white&style=for-the-badge)](https://github.com/ArchAdept/archadeptcli/releases)
  [![Operating Systems](https://img.shields.io/badge/os-linux%20%7C%20macOS%20%7C%20windows-yellow?style=for-the-badge)](https://github.com/ArchAdept/archadeptcli)
  [![Architectures](https://img.shields.io/badge/arch-x86__64%20%7C%20arm64-purple?style=for-the-badge)](https://github.com/ArchAdept/archadeptcli)
  [![PyPI - License](https://img.shields.io/pypi/l/archadeptcli?color=03cb98&style=for-the-badge)](https://github.com/ArchAdept/archadeptcli/blob/main/LICENSE.md)

  Command line interface for building, running, debugging, and disassembling the
  ArchAdept training course example projects.




  Many of the lessons on our training courses involve practical coding exercises
  for you to complete, or example code snippets for you to modify and run yourself
  on simulated hardware.

  One challenge often faced by newcomers to bare metal ARM architecture development
  like this is getting all of the necessary tools installed and configured, especially
  when accounting for all the differences between the Mac, Linux, and Windows
  operating systems.

  The ArchAdept CLI solves this issue by leveraging Docker containers "under-the-hood"
  to provide a consistent environment that is preloaded and preconfigured with all
  of the tools required to build, run, debug, and disassemble the ArchAdept training
  course example projects, while abstracting away all of the complexities of managing
  the actual Docker containers themselves.




  Tested as working on:

  | Operating System  | Version                    | x86_64 | arm64 |
  | ----------------- | -------------------------- | ------ | ----- |
  | Mac               | macOS Sonoma 14.1          | TODO   | 🟢    |
  | Windows 10        | Windows 10 Enterprise 22H2 | 🟢     | N/A   |
  | Windows 11        | TODO                       | TODO   | TODO  |
  | Linux             | Ubuntu 22.04 LTS           | 🟢     | TODO  |

  Click to expand for your operating system:
  <details>
  <summary>macOS instructions</summary>

  1. Install Docker Desktop by following the instructions at: https://www.docker.com/products/docker-desktop/

  2. Install Homebrew by following the instructions at: https://brew.sh

  3. Install Python 3.8 or newer via Homebrew:
  ```console
  $ brew search python3
  $ brew install python@3.12  # Chosen from results of `brew search python3`
  ```

  4. Install `pipx` via Homebrew:
  ```console
  $ brew install pipx
  ```

  5. Let pipx correctly update your `$PATH`:
  ```console
  $ pipx ensurepath
  ```

  6. From a new terminal window, install the ArchAdept CLI via `pipx`:
  ```console

  $ pipx install archadeptcli
  ```

  7. Ensure the ArchAdept CLI is installed and accessible:
  ```console
  $ archadept --help
  ```

  8. To update the ArchAdept CLI in future:
  ```console
  $ pipx upgrade archadeptcli
  ```

  > [!TIP]
  > Run `archadept pull` now to download the backend Docker image ahead of time; this may take a few minutes to complete.

  Proceed to [usage](#usage).
  </details>

  <details>
  <summary>Windows instructions</summary>

  1. Install Docker Desktop by following the instructions at: https://www.docker.com/products/docker-desktop/

  2. Install Python 3.8 or newer from https://www.python.org/downloads/windows/

  > [!WARNING]
  > We strongly recommend *not* using the Microsoft Store to install Python 3; please download and install from the official Python website.
  >
  > Furthermore, during installation, please ensure you tick the checkbox to add Python to your `$PATH`.

  3. Install `pipx` via `pip`:
  ```console
  PS> py -3 -m pip install --user pipx
  ```

  4. Let `pipx` correctly update your `$PATH`:
  ```console
  PS> py -3 -m pipx ensurepath
  ```

  5. From a new terminal window, install the ArchAdept CLI via `pipx`:
  ```console

  PS> py -3 -m pipx install archadeptcli
  ```

  6. Ensure the ArchAdept CLI is installed and accessible:
  ```console
  PS> archadept --help
  ```

  7. To update the ArchAdept CLI in future:
  ```console
  PS> py -3 -m pipx upgrade archadeptcli
  ```

  > [!TIP]
  > Run `archadept pull` now to download the backend Docker image ahead of time; this may take a few minutes to complete.

  Proceed to [usage](#usage).
  </details>

  <details>
  <summary>Linux instructions</summary>

  1. Install Docker Desktop by following the instructions at: https://www.docker.com/products/docker-desktop/

  2. Use your distribution's package manager to check the installed version of
     Python 3, for example on Ubuntu using `apt`:
  ```console
  $ apt show python3 | grep Version
  Version: 3.10.6-1~22.04
  ```

  3. If necessary, use your distribution's package manager to upgrade to Python 3.8
     or newer, for example on Ubuntu using `apt`:
  ```console
  $ sudo apt upgrade python3
  ```

  4. Install `pipx` via `pip`:
  ```console
  $ python3 -m pip install --user pipx
  ```

  5. Let `pipx` correctly update your `$PATH`:
  ```console
  $ python3 -m pipx ensurepath
  ```

  6. From a new terminal window, install the ArchAdept CLI via `pipx`:
  ```console

  $ python3 -m pipx install archadeptcli
  ```

  7. Ensure the ArchAdept CLI is installed and accessible:
  ```console
  $ archadept --help
  ```

  8. To update the ArchAdept CLI in future:
  ```console
  $ python3 -m pipx upgrade archadeptcli
  ```

  > [!TIP]
  > Run `archadept pull` now to download the backend Docker image ahead of time; this may take a few minutes to complete.

  Proceed to [usage](#usage).
  </details>



  The following commands are available:

  | Command | Description                                                                |
  | ------- | -------------------------------------------------------------------------- |
  | `make`  | Invoke an ArchAdept project Makefile.                                      |
  | `run`   | Run an ArchAdept project on a QEMU simulation of real hardware.            |
  | `debug` | Attach debugger to an ArchAdept project running on a live QEMU simulation. |
  | `pull`  | Pull the latest backend Docker image.                                      |
  | `prune` | Cleanup any lingering Docker containers.                                   |




  ```console
  usage: archadept make [-h] [-v] [-p PROJECT] [-i IMAGE] [-t TAG] [TARGET]

  Invokes an ArchAdept example project Makefile.

  options:
    -h, --help  show this help message and exit
    -v          enable logging verbose debug messages

  command-specific options:
    -p PROJECT    path to the ArchAdept project (default: current directory)
    -i IMAGE      override Docker image repository (default: archadept/archadeptcli-backend)
    -t TAG        override Docker image tag (default: latest)
    -S            interleave source with disassembly (only available for 'dis' target)
    -O {0,1,2,3}  override project's default optimization level

  command-specific positional arguments:
    TARGET      Makefile target from {all,clean,rebuild,dis,syms} (default: all)
  ```

  The following targets are defined by all ArchAdept training course example
  project Makefiles:
   - `all` builds the project.
   - `clean` deletes all of a project's build artifacts.
   - `rebuild` performs a clean build, equivalent to `clean` followed by `all`.
   - `dis` rebuilds the project, then disassembles it.
   - `syms` rebuilds the project, then dumps its symbol table.
   - `sects` rebuilds the project, then dumps its section headers.

  Note: The `dis` target accepts the following optional flags:
   - `-S` enables interleaving source code with the disassembly.




  ```console
  usage: archadept run [-h] [-v] [-p PROJECT] [-i IMAGE] [-t TAG] [-s]

  Runs an ArchAdept example project on a simulated Raspberry Pi 3b using QEMU.

  options:
    -h, --help  show this help message and exit
    -v          enable logging verbose debug messages

  command-specific options:
    -p PROJECT  path to the ArchAdept project (default: current directory)
    -i IMAGE    override Docker image repository (default: archadept/archadeptcli-backend)
    -t TAG      override Docker image tag (default: latest)
    -s          spawn GDB debug server and pause simulation at kernel entrypoint
  ```

  To quit the QEMU simulation, press `Ctrl-a` followed by `x`.




  ```console
  usage: archadept debug [-h] [-v] CONTAINER

  Attaches an LLDB debug session to a live QEMU simulation started by `archadept run -s`.

  options:
    -h, --help  show this help message and exit
    -v          enable logging verbose debug messages

  command-specific positional arguments:
    CONTAINER   container in which the QEMU simulation is running, as given by `archadept run`
  ```




  ```console
  usage: archadept pull [-h] [--version] [-v] [-i IMAGE] [-t TAG]

  Pulls the latest ArchAdept CLI backend Docker image from DockerHub.

  options:
    -h, --help  show this help message and exit
    --version   display archadeptcli version info
    -v          enable logging verbose debug messages

  command-specific options:
    -i IMAGE    override Docker image repository (default: archadept/archadeptcli-backend)
    -t TAG      override Docker image tag (default: latest)
  ```




  ```console
  usage: archadept prune [-h] [-v]

  Cleans up any lingering Docker containers from previous ArchAdept CLI invocations.

  options:
    -h, --help  show this help message and exit
    -v          enable logging verbose debug messages
  ```


pkgId: e7b5d89e9e25b9b7ad8e6ecadef0f9e8da05a27635e0e8133463cff651a6c108
name: python-archaea
arch: src
version: 1.1.28
epoch: 0
release: 1
summary: Playground for geometry.
url: https://github.com/archaeans/archaea
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archaea-1.1.28-1.src.rpm
checksum_type: sha256
description:
  Archaea is a base geometric library that includes basic geometric objects
  to create meshes and triangulated exports of meshes.

  Motivation of creating this library is started with master thesis, departments of Computational
  Science and Engineering and Architecture at Istanbul Technical University.
  Aim of thesis is to create geometric definitions for different environmental
  solvers like EnergyPlus and OpenFOAM to run them parallely on Linux environment.

  Archaea is a geometrical playground for now, most important functionality of library
  is executing earcut algorithm on 3D coordinate system by plane (u, v) transformations.
  Shortly library can create triangulations with holes on 3D.




  - CoordinateArray: Base object for vectoral operations on Vector and Point objects.
  - Vector, Vector2d, Vector3d: Vector operations like Dot and Cross Product, also
  serves transformations of other geometrical objects.
  - Point, Point2d, Point3d: Position object to construct other geometric objects
  like LineSegment, Polyline, Mesh..
  - LineSegment: Construct with start and end point.
  - Polyline: List of consecutive LineSegments
  - Loop: Closed polyline definition.
  - Face: Face is a loop definition that might have holes with inner loops.
  - Mesh: Polygon and vertex list definition for exporting.




  - Move: Objects can be moved by creating copy of source object.
  - Reverse: LineSegment, Polyline, Loop and Face can be reversed.
  - Offset: Loops and Faces can be offseted.
  - Extrude: Faces can be extruded that creates list of Faces. Holes also covered.





  ```bash
  git clone git@github.com:archaeans/archaea.git

  mkdir venv

  sudo apt install python3.10-venv

  python3 -m venv $HOME/..path../archaea/venv

  source ./venv/bin/activate

  python3 setup.py install

  ```

  !!! NOTE
      if `python3 setup.py install` doesn't install dependencies, try to install them separately like `pip3 install numpy-stl`



  1. Ctrl + Shift + P

  2. Python: Select Interpreter

  3. Enter Interpreter Path

  4. Find python in virtual environment /venv/bin/python


pkgId: d450647f702077578a725ecde854424a0ca3b58beed4b626710e881f2bcd5a6d
name: python-archaea-simulation
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: Wrapper definitions for simulation tools.
url: https://github.com/archaeans/archaea-simulation
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archaea-simulation-1.2.2-1.src.rpm
checksum_type: sha256
description:
  Wrapper definitions for simulation tools.

  Motivation of creating this library is started with master thesis, departments of Computational
  Science and Engineering and Architecture at Istanbul Technical University.
  Aim of thesis is to create scenarios for different environmental
  solvers like EnergyPlus and OpenFOAM to run them parallely on Linux environment.
  Preparation of these scenario files done by geometric [Archaea](https://github.com/archaeans/archaea) library.




  - OpenFOAM: OpenFOAM requires stl geometries to run it's solvers
  behind the scenes. (Pre-Alpha)
  - EnergyPlus: EnergyPlus requires idf schema to run simulations. (MVP)
  - UWG: Urban weather generator is a solver to calculate effects on urban microclimate.
  It creates new .epw file for EnergyPlus simulations.

  Main idea behind this work is to be experimental and didactic.


pkgId: 3a1f529646199ecaac14742c9707f1d6195f3dbe5009944da0e913b513d2610e
name: python-archeai
arch: src
version: 0.0.5
epoch: 0
release: 1
url: https://pypi.org/project/archeai/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archeai-0.0.5-1.src.rpm
checksum_type: sha256
summary:
  ArcheAI is a lightweight Python framework that simplifies AI agent development. Build smarter, more capable agents with ease using ArcheAI's easy tool integration, LLM interaction, and agent orchestration.

description:
  <div style="background-color: #f0f0f0; padding: 15px; border-radius: 5px;">
  ArcheAI is a lightweight Python framework designed to make AI agent development intuitive, flexible, and downright fun! 🎉
  > "Another AI agent framework? What makes ArcheAI different?" 🤔
  Let's break it down:
  1. **Simplicity First** 🧘
     - Strip away unnecessary complexity
     - Clean and elegant API
  2. **Unleash Your Creativity** 🎨
     - Modular design for experimentation
     - Support for various LLMs (Gemini, Groq, Cohere, OpenAI, Anthropic)
  3. **Power in Collaboration** 🤝
     - TaskForce feature for seamless agent orchestration
  4. **Built for Exploration** 🔭
     - Flexible foundation ready to adapt to new technologies


pkgId: c3c5c5ebb3b146cf0e093ea637896b23cd646416df5dc1a52576b4793757ff36
name: python-archeo
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/archeo/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archeo-0.1.1-1.src.rpm
checksum_type: sha256
description:
  The following example demonstrates how to use the package to visualize the prior and posterior distributions of a single event.

  ```python
  import archeo



  mass_posterior = [68.0, 71.4, ..., 91.4]
  spin_posterior = [0.31, 0.54, ..., 0.64]


  prior = archeo.Prior.from_prior_config("precessing")

  posterior = prior.to_posterior(mass_posterior, spin_posterior)


  archeo.visualize_prior_distribution(prior, output_dir="./")
  archeo.visualize_posterior_estimation({"GW190521": posterior}, output_dir="./")
  ```



  Check out the preset priors in [precessing.py](./archeo/preset/precessing.py) and [aligned_spin.py](./archeo/preset/aligned_spin.py). From that, one should be able to create their own prior by following the same structure.


pkgId: 1a7931cbabb75afdea5c588c9dca22e9b4d4a005ce4d857fdfb36df9e243800b
name: python-archeo
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: A Bayesian framework for estimating natal mass, kick, and spin of black holes.
url: https://pypi.org/project/archeo/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archeo-1.0.3-1.src.rpm
checksum_type: sha256
description:
  [![github](https://img.shields.io/badge/GitHub-archeo-blue.svg)](https://github.com/wyhwong/archeo)
  [![PyPI version](https://badge.fury.io/py/archeo.svg)](https://pypi.org/project/archeo/)
  [![license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/wyhwong/archeo/blob/main/LICENSE)



  The following example demonstrates how to use the package to visualize the prior and posterior distributions of a single event.

  ```python
  import archeo



  mass_posterior = [68.0, 71.4, ..., 91.4]
  spin_posterior = [0.31, 0.54, ..., 0.64]


  prior = archeo.Prior.from_config("precessing")

  posterior = prior.to_posterior(mass_posterior, spin_posterior)


  archeo.visualize_prior_distribution(prior, output_dir="./")
  archeo.visualize_posterior_estimation({"GW190521": posterior}, output_dir="./")
  ```



  Check out the preset priors in [precessing.py](https://github.com/wyhwong/archeo/blob/main/src/archeo/preset/precessing.py) and [aligned_spin.py](https://github.com/wyhwong/archeo/blob/main/src/archeo/preset/aligned_spin.py). From that, one should be able to create their own prior by following the same structure.


pkgId: 86bece509716b00bb1d0242a4f7bfb2331c4b668e645746a3935676e0470f880
name: python-archeo
arch: src
version: 1.0.7
epoch: 0
release: 1
summary: A Bayesian framework for estimating natal kick, ancestral masses and spins of black holes.
url: https://pypi.org/project/archeo/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archeo-1.0.7-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/archeo.svg)](https://pypi.org/project/archeo/)
  [![Python version](https://img.shields.io/pypi/pyversions/archeo)](https://pypi.org/project/archeo/)
  [![Downloads](https://img.shields.io/pepy/dt/archeo)](https://github.com/wyhwong/archeo)
  [![license](https://img.shields.io/badge/license-MIT-orange.svg)](https://github.com/wyhwong/archeo/blob/main/LICENSE)
  [![CI](https://github.com/wyhwong/archeo/actions/workflows/main.yml/badge.svg)](https://github.com/wyhwong/archeo/actions/workflows/main.yml/)



  The following example demonstrates how to use the package to visualize the prior and posterior distributions of a single event.

  ```python
  import archeo



  mass_posterior = [68.0, 71.4, ..., 91.4]
  spin_posterior = [0.31, 0.54, ..., 0.64]


  prior = archeo.Prior.from_config("precessing")

  posterior = prior.to_posterior(mass_posterior, spin_posterior)


  archeo.visualize_prior_distribution(prior, output_dir="./")
  archeo.visualize_posterior_estimation({"GW190521": posterior}, output_dir="./")
  ```



  Check out the preset priors in [precessing.py](https://github.com/wyhwong/archeo/blob/main/src/archeo/preset/precessing.py) and [aligned_spin.py](https://github.com/wyhwong/archeo/blob/main/src/archeo/preset/aligned_spin.py). From that, one should be able to create their own prior by following the same structure.


pkgId: ad535fcc6cd04d7fd2dab153bcf876470ffde5d845d8fbbd67dcd64209ee1536
name: python-archeryutils
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: A collection of archery utilities in python.
url: https://github.com/jatkinson1000/archeryutils
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archeryutils-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://img.shields.io/pypi/v/archeryutils)](https://pypi.org/project/archeryutils)
  ![GitHub](https://img.shields.io/github/license/jatkinson1000/archeryutils)
  [![Documentation Status](https://readthedocs.org/projects/archeryutils/badge/?version=latest)](https://archeryutils.readthedocs.io/en/latest/?badge=latest)
  ![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/jatkinson1000/archeryutils/testing.yaml)
  [![codecov](https://codecov.io/gh/jatkinson1000/archeryutils/branch/main/graph/badge.svg?token=AZU7G6H8T0)](https://codecov.io/gh/jatkinson1000/archeryutils)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/jatkinson1000/archeryutils/main?labpath=examples.ipynb)

  A collection of archery code and utilities in python.\
  Designed to make the development of archery codes and apps easier.

  Contains:
  - generic representations of targets and rounds
  - World Archery, Archery GB, IFAA rounds
  - calculations for Archery GB handicaps and Archery Australia archer skill level
  - calculation of Archery GB classifications

  Full documentation, including an API reference, is available on
  [read the docs](https://archeryutils.readthedocs.io).



  You can play with this library as a
  [binder instance](https://mybinder.org/v2/gh/jatkinson1000/archeryutils/main?labpath=examples.ipynb)
  right now without installing anything.
  If you want to use it locally in your own code follow the usage instructions below for
  [installation](#installation) and getting started.



  Usage is allowed under the [licensing specified](https://github.com/jatkinson1000/archeryutils#license).
  We encourage usage and welcome feature requests.
  It is appreciated if visible credit is given by any projects using `archeryutils`.


  To install the library via pip for use in a project you can run:

      pip install archeryutils

  It is recommended to use a virtual environment.

  If you want a local install that you can edit instead, clone the repository,
  navigate to `archeryutils/`, and run:

      python3 -m pip install -e .[test,lint,docs]

  Please refer to the online documentation for
  [full installation guidance](https://archeryutils.readthedocs.io/en/latest/getting-started/installation.html).


  There are examples of some of the different functionalities in the jupyter notebook
  `examples.ipynb`.
  This can be run from a local install using:

      pip install notebook

      jupyter notebook examples.ipynb

  Alternatively, you can use it online through the
  [binder instance](https://mybinder.org/v2/gh/jatkinson1000/archeryutils/main?labpath=examples.ipynb)
  as described above.


  Copyright &copy; Jack Atkinson

  _archeryutils_ is distributed under the
  [MIT Licence](https://github.com/jatkinson1000/archeryutils/blob/main/LICENSE).


  See [Contributors](https://github.com/jatkinson1000/archeryutils/graphs/contributors)
  for a full list of contributors towards this project.

  If you use this software in your work, please provide visible credit/citation.
  [CITATION.cff](https://github.com/jatkinson1000/archeryutils/blob/main/CITATION.cff)
  provides citation metadata, which can also be accessed from
  [GitHub](https://github.com/jatkinson1000/archeryutils).


  The following projects make use of this code or derivatives in some way:

  - [archerycalculator](https://archerycalculator.co.uk)
  - MyTargets
  - Golden Records
  - Expert Archer

  Are we missing anyone? Let us know.

  If you make use of *archeryutils* in a commercial product please consider
  [supporting](#support) the project to ensure its continued development and longevity.



  Contributions and collaborations are welcome from anyone with an
  interest in python and archery.

  Please refer to the online documentation for full
  [contributing guidelines](https://archeryutils.readthedocs.io/en/latest/develop/contributing.html).\
  Read and follow this when opening
  [issues](https://archeryutils.readthedocs.io/en/latest/develop/contributing.html#bug-reports-and-feature-requests)
  or
  [pull requests](https://archeryutils.readthedocs.io/en/latest/develop/contributing.html#code-contributions).

  For bugs, feature requests, and clear suggestions for improvement can be documented by
  [opening an issue](https://github.com/jatkinson1000/archeryutils/issues).
  For more abstract ideas for the project please
  [open a discussion](https://github.com/jatkinson1000/archeryutils/discussions).

  If you built something upon _archeryutils_ that would be useful to others, or can
  address an [open issue](https://github.com/jatkinson1000/archeryutils/issues), please
  [fork the repository](https://github.com/jatkinson1000/archeryutils/fork) and open a
  pull request.


  Everyone participating in the _archeryutils_ project, and in particular in the
  issue tracker, pull requests, and social media activity, is expected to treat other
  people with respect and more generally to follow the guidelines articulated in the
  [Python Community Code of Conduct](https://www.python.org/psf/codeofconduct/).



  This project is developed by volunteers for the benefit of the archery community.
  It is dedicated to remain a [FOSS](https://itsfoss.com/what-is-foss/) project.
  The best way to support this project, if you are able, is by directly
  [contributing](https://github.com/jatkinson1000/archeryutils/tree/project-documentation#contributions).

  If you are unable to do this, however, financial support towards this and the
  [archerycalculator](https://archerycalculator.co.uk) project can be given through
  [Buy me a coffee](https://www.buymeacoffee.com/jackatkinsr) or
  [donating via paypal](https://www.paypal.com/donate/?hosted_button_id=JEABJ3UJU4XD4).
  This allows me to spend time improving the library.

rpm_license:
  MIT License  Copyright (c) 2022 Jack Atkinson  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: 22b482dc489d4b53047c01f6d3945dfb7b1223e8980078776eb42626b1d32955
name: python-arches
arch: src
version: 7.6.2
epoch: 0
release: 1
url: https://archesproject.org/
rpm_license: GNU AGPL3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arches-7.6.2-1.src.rpm
checksum_type: sha256
summary:
  Arches is an open-source, web-based, geospatial information system for cultural heritage inventory and management.

description:
  Arches is a web-based, geospatial information system for cultural heritage inventory and management. Arches is purpose-built for the international cultural heritage field, and designed to record all types of immovable heritage, including archaeological sites, buildings and other historic structures, landscapes, and heritage ensembles or districts. For more information and background on the Arches project, please visit [archesproject.org](http://archesproject.org/).

  For general inquiries and to get technical support from the wider Arches community, visit our [Community Forum](https://community.archesproject.org/).

  For general user installation and app documentation, visit [arches.readthedocs.io](https://arches.readthedocs.io).

  For the documentation pertaining to the bleeding edge code (what is in the ``master`` branch), visit [arches.readthedocs.io/en/latest](https://arches.readthedocs.io/en/latest).  We welcome new contributors; please see [Contributing to Arches](CONTRIBUTING.md) for details.

  Issue reports are encouraged! [Please read this article](http://polite.technology/reportabug.html) before reporting issues.
  *   [Report a Bug](https://github.com/archesproject/arches/issues/new?template=bug.md)
  *   [File a Feature Ticket](https://github.com/archesproject/arches/issues/new?template=feature.md)

  [Version 7.6.1 release notes](https://github.com/archesproject/arches/blob/dev/7.6.x/releases/7.6.1.md)



  Installation is fully documented in the official documentation, [arches.readthedocs.io/en/stable](https://arches.readthedocs.io/en/stable), but assuming you have all of the dependencies installed you should make a virtual environment, activate it, and then run
  ```
      pip install arches
  ```
  then
  ```
      arches-project create myproject
  ```
  enter the new `myproject` directory
  ```
      cd myproject
  ```
  and run
  ```
      python manage.py setup_db
      python manage.py runserver
  ```
  in a separate terminal, activate your virtual environment and navigate to the root directory of the project ( you should be on the same level as `package.json`)
  ```
      cd myproject/myproject
  ```
  and run
  ```
      npm run build_development
  ```
  to create a frontend asset bundle. This process should complete in less than 2 minutes.

  Finally, visit `localhost:8000` in a browser (only Chrome is fully supported at this time).

  If you run into problems, please review our full [installation documentation](http://arches.readthedocs.io/en/stable/installation/)



  Our general release cycle will typically be a functional release (either major if there are backward incompatible changes or minor, if there are not) every 9 months. Each functional release will typically be followed by one or more patch releases. See [semver.org](https://semver.org/) for version numbering.

  -   Functional releases will usually introduce new functionality to the application, but could also include styling updates, enhancements to the UX, bug fixes, and performance improvements.
  -   Patch releases are really only concerned with fixing any bugs related to the previous release or any other issues not yet addressed



  - LTS (Long Term Support) releases will be maintained with patch releases for at least 27 months. Typically an LTS release will be the second minor release following a major release.
  - Feature releases (with the exception of stable releases) will be supported only until the next feature release. After that users are expected to upgrade to the latest release on [pypi.python.org](https://pypi.python.org/pypi/arches)



  The following a general plan for the Arches project. Be aware this plan is tentative and subject to change.


  - Activity stream enhancements
  - Support for editing and publishing graphs without having to remove resource instances
  - Support for viewing and restoring previous graph publications
  - Support for configuring currently published graphs
  - Support for search through resource relationships
  - Persistent uris for resource instance and tile data
  - Implementation resource lifecycles
  - Bulk Data Manager CLI interface
  - Migration to MapLibre
  - Django 5.2 support
  - Python 3.11 becomes minimum Python version


  - Arches References
  - Arches Lingo


  - Full migration to Vue
  - Deprecation of the RDM
  - Deprecation of the following datatypes:
      - concept
      - concept-list
      - domain
      - domain-list datatypes


pkgId: 3313d34d261c1650e70f87a3f5ae776b205d12cc7890d431ed44521d6594f68a
name: python-arches
arch: src
version: 7.6.3
epoch: 0
release: 1
url: https://archesproject.org/
rpm_license: GNU AGPL3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arches-7.6.3-1.src.rpm
checksum_type: sha256
summary:
  Arches is an open-source, web-based, geospatial information system for cultural heritage inventory and management.

description:
  Arches is a web-based, geospatial information system for cultural heritage inventory and management. Arches is purpose-built for the international cultural heritage field, and designed to record all types of immovable heritage, including archaeological sites, buildings and other historic structures, landscapes, and heritage ensembles or districts. For more information and background on the Arches project, please visit [archesproject.org](http://archesproject.org/).

  For general inquiries and to get technical support from the wider Arches community, visit our [Community Forum](https://community.archesproject.org/).

  For general user installation and app documentation, visit [arches.readthedocs.io](https://arches.readthedocs.io).

  For the documentation pertaining to the bleeding edge code (what is in the ``master`` branch), visit [arches.readthedocs.io/en/latest](https://arches.readthedocs.io/en/latest).  We welcome new contributors; please see [Contributing to Arches](CONTRIBUTING.md) for details.

  Issue reports are encouraged! [Please read this article](http://polite.technology/reportabug.html) before reporting issues.
  *   [Report a Bug](https://github.com/archesproject/arches/issues/new?template=bug.md)
  *   [File a Feature Ticket](https://github.com/archesproject/arches/issues/new?template=feature.md)

  [Version 7.6.3 release notes](https://github.com/archesproject/arches/blob/dev/7.6.x/releases/7.6.3.md)



  Installation is fully documented in the official documentation, [arches.readthedocs.io/en/stable](https://arches.readthedocs.io/en/stable), but assuming you have all of the dependencies installed you should make a virtual environment, activate it, and then run
  ```
      pip install arches
  ```
  then
  ```
      arches-project create myproject
  ```
  enter the new `myproject` directory
  ```
      cd myproject
  ```
  and run
  ```
      python manage.py setup_db
      python manage.py runserver
  ```
  in a separate terminal, activate your virtual environment and navigate to the root directory of the project ( you should be on the same level as `package.json`)
  ```
      cd myproject/myproject
  ```
  and run
  ```
      npm run build_development
  ```
  to create a frontend asset bundle. This process should complete in less than 2 minutes.

  Finally, visit `localhost:8000` in a browser (only Chrome is fully supported at this time).

  If you run into problems, please review our full [installation documentation](http://arches.readthedocs.io/en/stable/installation/)



  Our general release cycle will typically be a functional release (either major if there are backward incompatible changes or minor, if there are not) every 9 months. Each functional release will typically be followed by one or more patch releases. See [semver.org](https://semver.org/) for version numbering.

  -   Functional releases will usually introduce new functionality to the application, but could also include styling updates, enhancements to the UX, bug fixes, and performance improvements.
  -   Patch releases are really only concerned with fixing any bugs related to the previous release or any other issues not yet addressed



  - LTS (Long Term Support) releases will be maintained with patch releases for at least 27 months. Typically an LTS release will be the second minor release following a major release.
  - Feature releases (with the exception of stable releases) will be supported only until the next feature release. After that users are expected to upgrade to the latest release on [pypi.python.org](https://pypi.python.org/pypi/arches)



  The following a general plan for the Arches project. Be aware this plan is tentative and subject to change.


  - Activity stream enhancements
  - Support for editing and publishing graphs without having to remove resource instances
  - Support for viewing and restoring previous graph publications
  - Support for configuring currently published graphs
  - Support for search through resource relationships
  - Persistent uris for resource instance and tile data
  - Implementation resource lifecycles
  - Bulk Data Manager CLI interface
  - Migration to MapLibre
  - Django 5.2 support
  - Python 3.11 becomes minimum Python version


  - Arches References
  - Arches Lingo


  - Full migration to Vue
  - Deprecation of the RDM
  - Deprecation of the following datatypes:
      - concept
      - concept-list
      - domain
      - domain-list datatypes


pkgId: 7ae847fd75fd22e72bb0ecdbd8bbc3d3e25bab261132a9a29be459c1bce59a9a
name: python-arches-for-science
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/arches-for-science/
rpm_license: GNU AGPL3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arches-for-science-2.0.0-1.src.rpm
checksum_type: sha256
description:
  Arches for Science an Arches Application designed to help conservation scientists record, manage, and visualize laboratory data.


  Please see the [project page](http://archesproject.org/) for more information on the Arches project.




  If you are installing Arches for Science for the first time, you can install it as an Arches application into a project or run it directly as an Arches project. Running Arches for Science as a project can provide some convienience if you are a developer contributing to the Arches for Science project. Otherwise, **we strongly recommend running Arches for Science as an Arches Application** within a project because that will allow greater flexibility in customizing your project without the risk of conflicts when upgrading to the next version of Arches for Science.



  Clone the arches-for-science repo and checkout the latest `dev/x.x.x` branch.
  Navigate to the `arches-for-science` directory from your terminal and run:
  ```
  pip install -e .
  ```
  `Important`: Installing the arches-for-science app will install Arches as a dependency. This may replace your current install of Arches with a version from PyPi. If you've installed Arches for development using the `--editable -e` flag, you'll need to re pip install arches after installing arches-for-science


  ```
  pip install arches-for-science
  ```




  1. If you don't already have an Arches project, you'll need to create one by following the instructions in the Arches [documentation](http://archesproject.org/documentation/).
  Since Arches for Science uses `Cantaloupe` as its IIIF server, take notice of the
  Cantaloupe [installation instructions](https://arches.readthedocs.io/en/stable/developing/advanced/managing-and-hosting-iiif/), too.

  2. When your project is ready, add "arches_templating", "arches_for_science", and "pgtrigger" to INSTALLED_APPS **below** the name of your project:
      ```
      INSTALLED_APPS = (
          ...
          "my_project_name",
          "arches_templating",
          "arches_for_science",
          "pgtrigger",
      )
      ```

  3. Make sure the following settings are added to your project
      ```
      FUNCTION_LOCATIONS.append("arches_for_science.functions")

      TEMPLATES = build_templates_config(
          debug=DEBUG,
          app_root=APP_ROOT,
          context_processors=[
              "django.contrib.auth.context_processors.auth",
              "django.template.context_processors.debug",
              "django.template.context_processors.i18n",
              "django.template.context_processors.media",
              "django.template.context_processors.static",
              "django.template.context_processors.tz",
              "django.template.context_processors.request",
              "django.contrib.messages.context_processors.messages",
              "arches.app.utils.context_processors.livereload",
              "arches.app.utils.context_processors.map_info",
              "arches.app.utils.context_processors.app_settings",
              "arches_for_science.utils.context_processors.project_settings",
          ],
      )

      RENDERERS += [
          {
              "name": "xy-reader",
              "title": "XY Data File Reader",
              "description": "Use for all instrument outputs with x-y data",
              "id": "e93b7b27-40d8-4141-996e-e59ff08742f3",
              "iconclass": "fa fa-bolt",
              "component": "views/components/cards/file-renderers/xy-reader",
              "ext": "txt",
              "type": "text/plain",
              "exclude": "",
          },
      ]

      XY_TEXT_FILE_FORMATS = ["txt"]

      X_FRAME_OPTIONS = "SAMEORIGIN"
      ```

  4. Next ensure arches and arches_for_science are included as dependencies in package.json
      ```
      "dependencies": {
          "@uppy/aws-s3": "3.6.2",
          "@uppy/core": "3.13.0",
          "@uppy/dashboard": "3.9.0",
          "@uppy/drag-drop": "3.1.0",
          "@uppy/progress-bar": "3.1.1",
          "@uppy/companion-client": "3.1.3",
          "typescript": "5.6.2",
          "arches": "archesproject/arches#dev/7.6.x",
          "arches_for_science": "archesproject/arches-for-science#dev/2.0.x"
      }
      ```

  5. Update urls.py to include the arches-for-science urls
      ```
      urlpatterns = [
          path("", include("arches.urls")),
          path("", include("arches_for_science.urls")),
          path("reports/", include("arches_templating.urls")),
      ] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
      ```

  6. Install the arches application package (models and other data)
      ```
      python manage.py packages -o load_package -a arches_for_science -dev -y
      ```

  7. Start your project
      ```
      python manage.py runserver
      ```

  8. Next cd into your project's app directory (the one with package.json) install and build front-end dependencies:
      ```
      npm install
      npm run build_development
      ```


pkgId: d56a422e7103148f900e6bb8e7453013631a66c59fed38b73eafabfb4104775e
name: python-archethic
arch: src
version: 0.0.1.2
epoch: 0
release: 1
summary: ArchEthic Python SDK
url: https://github.com/aime-risson/archethic-python-sdk
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archethic-0.0.1.2-1.src.rpm
checksum_type: sha256
description:
  This repo aims to provide a Python SDK for the ArchEthic project.<br>
  It is based on the [official javascript sdk](https://github.com/archethic-foundation/libjs).


  ```pip install archethic```



  ```python
  import archethic

  api = archethic.Api("https://testnet.archethic.net")


  seed = 'mySuperSeed'
  ref_index = api.get_transaction_index(archethic.derive_address(seed, 0))

  rx_address = archethic.derive_address("rx_address", 0)

  tx = archethic.TransactionBuilder('transfer')
  tx.add_uco_transfer(rx_address, 10.102)
  tx.build(seed, ref_index)
  tx.origin_sign(archethic.ORIGIN_PRIVATE_KEY)

  transaction_fee = api.get_transaction_fee(tx)
  print(f"fee : {transaction_fee['fee']} UCOs")
  response = api.send_tx(tx)
  print(response)




  ```




  Thank you for considering to help out with the source code.
  We welcome contributions from anyone and are grateful for even the smallest of improvement.

  Please to follow this workflow:
  1. Fork it!
  2. Create your feature branch (git checkout -b my-new-feature)
  3. Commit your changes (git commit -am 'Add some feature')
  4. Push to the branch (git push origin my-new-feature)
  5. Create new Pull Request


  (copied from archethic-foundation)


  - [x] Implementation of utils


  - [x] get_originKey()
  - [x] derive_keypair()
  - [x] derive_address()
  - [x] ec_encrypt()
  - [x] aes_encrypt()


  - [x] create TransactionBuilder class (TB)
  - [x] TB.set_code()
  - [x] TB.set_content()
  - [x] TB.add_ownership()
  - [x] TB.add_UCO_transfer()
  - [x] TB.add_TOKEN_transfer()
  - [x] TB.add_recipient()
  - [x] TB.build()
  - [x] TB.origin_sign()
  - [x] TB.toJSON()
  - [x] Interacting with other signer
    - [x] TB.previous_signature_payload()
    - [x] TB.set_previous_signature_and_previous_public_key()
    - [x] TB.set_address()
    - [x] TB.origin_signature_payload()
    - [x] TB.set_origin_sign()


  - [ ] addOriginKey()
  - [x] TB.send_transaction()
  - [ ] wait_confirmations()
  - [x] get_transaction_index()
  - [ ] get_storage_nonce_public_key()
  - [x] get_transaction_fee()
  - [x] get_transaction_ownerships()


  comming soon


pkgId: 54d88cc42820c7c16528b3f645447c875876b82c0dc477204c22fe1d54a9065f
name: python-archetypal
arch: src
version: 2.18.3
epoch: 0
release: 1
summary: Retrieve, construct, simulate, convert and analyse building archetypes
url: https://pypi.org/project/archetypal/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archetypal-2.18.3-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/samuelduchesne/archetypal/actions/workflows/python-package.yml/badge.svg?branch=main)](https://github.com/samuelduchesne/archetypal/actions/workflows/python-package.yml)
  [![Coverage Status](https://coveralls.io/repos/github/samuelduchesne/archetypal/badge.svg)](https://coveralls.io/github/samuelduchesne/archetypal)
  [![Documentation Status](https://readthedocs.org/projects/archetypal/badge/?version=latest)](https://archetypal.readthedocs.io/en/latest/?badge=latest)
  [![DOI](https://joss.theoj.org/papers/10.21105/joss.01833/status.svg)](https://doi.org/10.21105/joss.01833)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)



  **python for building simulation archetypes**

  Retrieve, construct, simulate, convert and analyze building simulation
  templates



  **Archetypal** is a Python package that helps handle building
  archetypes.



  The conversion of [EnergyPlus](https://energyplus.net) IDF models to
  Trnsys
  [TrnBuild](http://www.trnsys.com/features/suite-of-tools.php.html)
  Models (compatible with the multizone building model) is now part of a
  distinct package known as the
  [trnslator](https://github.com/louisleroy5/trnslator).



  Here is a short overview of features that are part of archetypal:

  1. Building Complexity Reduction: A utility to transform a multizone
     EnergyPlus model to a two-zone normalized model. Such models are
     called `building archetypes` and are the foundation of the
     [UMI Energy Module](https://umidocs.readthedocs.io/en/latest/docs/model-setup-template.html).
     This tool will allow any EnergyPlus model to be imported into
     [UMI](http://web.mit.edu/sustainabledesignlab/projects/umi/index.html)
     and drastically speedup the UBEM process.



  Recommended to use a conda environement running python 3.8. Pip install should work on all platforms (linux, macOS and Windows).
  First,

  ```cmd
  conda create -n venv python=3.8
  ```

  `-n venv` is the name of your environement; it can be anything.
  Then,

  ```cmd
  pip install -U archetypal
  ```



  1. Clone this repo locally

  ```console
  git clone https://github.com/samuelduchesne/archetypal.git
  ```

  2. Install dependencies:

  ```console
  cd archetypal
  conda env create
  ```

  This will create a new environment named `archetypal`. Don't forget to activate the environment.

  3. Run Tests:

  ```console
  python -m pytest tests/
  ```

  4. Generate Documentation:

  ```console
  make html
  ```


pkgId: 275be8c334815f806951958570b6cc8a1a3b64b84f4cb49017e7a32795c165b3
name: python-archetypes
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: A scikit-learn compatible Python package for archetypal analysis
url: https://pypi.org/project/archetypes/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archetypes-0.6.2-1.src.rpm
checksum_type: sha256
description:
  ![PyPI](https://img.shields.io/pypi/v/archetypes)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/archetypes)
  [![Python package](https://github.com/aleixalcacer/archetypes/actions/workflows/python-package.yml/badge.svg)](https://github.com/aleixalcacer/archetypes/actions/workflows/python-package.yml)
  ![PyPI - License](https://img.shields.io/pypi/l/archetypes)
  [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.0-4baaaa.svg)](CODE_OF_CONDUCT.md)

  **archetypes** is a [scikit-learn](https://scikit-learn.org) compatible Python package for archetypal analysis.




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

  ```bash
  pip install archetypes
  ```




  ```python
  import archetypes as arch
  import numpy as np

  X = np.random.normal(0, 1, (100, 2))

  aa = arch.AA(n_archetypes=4)

  X_trans = aa.fit_transform(X)

  ```



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

  Please make sure to update tests as appropriate.




  Distributed under the BSD 3-Clause License. See [LICENSE](LICENSE) for more information.


pkgId: 8d74c1174ef656cc5bd924a7bec054fea6f1b9e1ded2d47eca56d84a485158fa
name: python-archetypes.kss
arch: src
version: 1.7.3
epoch: 0
release: 1
summary: KSS (Kinetic Style Sheets) for Archetypes
url: http://plone.org
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archetypes.kss-1.7.3-1.src.rpm
checksum_type: sha256
description:
  KSS (Kinetic Style Sheets) for Archetypes
  This product gives generic KSS support to Archetypes. It depends on the product
  "kss.core" and "plone.app.kss".


pkgId: b3f038d6676cb1dea91c2ebf9a14b7bfdd1289a5aa32695c2788e0b9a457e5be
name: python-archetypesdk
arch: src
version: 1.0.16
epoch: 0
release: 1
url: https://github.com/ArchetypeAPI/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archetypesdk-1.0.16-1.src.rpm
checksum_type: sha256
summary:
  Python bindings for Archetype. Archetype makes API monetization and usage based billing for APIs easy.

description:
  The Archetype Python library provides convenient access to the Archetype API from applications written in Python. It includes a pre-defined set of classes for API resources that initialize themselves dynamically from API responses which makes it compatible with a wide range of versions of the Archetype API.

  The SDK has everything you need to build and manage API subscriptions, usage-based billing, tracking metered usage, issue volume based discounts, graduated pricing models and more.


  [Archetype](https://archetype.dev) is the revenue infrastruce that make API monetization quick and painless. It works by integrating powerful, reliable purchase server with cross-platform support. Our open-source framework provides a backend and a wrapper around payment processors like Stripe to save engineers months from having to build custom billing infrastructure for their APIs.

  Whether you are building a new API or already have millions of customers, you can use Archetype to:

  -   Fetch products, make purchases, and check subscription status with our  [native SDKs](https://docs.archetype.dev/docs/installation).
  -   Host add [configure products](https://docs.archetype.dev/docs/products) remotely from our dashboard.
  -   Analyze the most important metrics for your app business  [in one place](https://docs.archetype.dev/docs/analytics).
  -   See customer transaction histories, chart lifetime value, and  [grant promotional subscriptions](https://docs.archetype.dev/docs/users).

  Sign up to [get started](https://app.archetype.dev/signup).





  If looking to use our APIs directly, the [API reference](https://docs.archetype.dev/reference/basic) is here.

  With Archetype, you can keep track of all your app transactions in one place — whether your customers are charged through iOS, Android, or the web. As the single source of truth for your API business, we make sure your customers' subscription status is always up to date.




  **[Explore the docs and view the quickstart guide](https://docs.archetype.dev/docs/quickstart-guide)**

  You don't need this source code unless you want to modify the package. If you just want to use the package, just run:

  ```sh
  pip install --upgrade archetypesdk
  ```




  Python 3.6+ (PyPy supported)




  The library needs to be configured with your account's **app_id** and **secret key** which is available in your **[Archetype Dashboard](app.archetype.dev/settings)**. Set `archetype.app_id` and `archetype.secret_key` to their values:

  ```python
  import archetypesdk as archetype

  archetype.app_id = "ARCHETYPE_APP_ID"
  archetype.secret_key = "ARCHETYPE_SECRET_KEY"

  CUSTOM_CUSTOMER_UID = "XXX"


  customers = archetype.Customer.All()


  print(customers[0]["email"])


  customer = archetype.Customer.Retrieve(CUSTOM_CUSTOMER_UID)


  print(customer["email"])



  archetype.BillableMetric.LogUsage(
      custom_uid=CUSTOM_CUSTOMER_UID,
      billable_metric_id=BILLABLE_METRIC_ID,
      used_amount=AMOUNT,
  )




  from flask import Flask

  app = Flask(__name__)

  @app.route("/a", methods=["GET", "POST"])
  @archetype.Auth
  def auth_test_url():
      return jsonify({"response": "success!"}), 200



  @archetype.Auth
  def sensitive_fbv(request, *args, **kwargs):
      return HttpResponse()


  from archetypesdk.fastapi import authorized

  @app.get("/authorize")
  async def hello_world(is_authorized = Depends(authorized)):
      return {"response": "Success"}


  ```

  You can leverage the SDK to create and configure billable metrics, products, token management, authorization and more. Check out [the docs](https://docs.archetype.dev/docs/welcome) for more examples and use cases.


pkgId: 3381a4a7494e1080438c7c2e3e589b35f3d4c57db60d2768ae4e0ff84511179e
name: python-archfx-cloud
arch: src
version: 0.16.0
epoch: 0
release: 1
summary: Python client for https://archfx.io
url: https://github.com/iotile/python_archfx_cloud
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archfx-cloud-0.16.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/archfx_cloud.svg)](https://pypi.python.org/pypi/archfx-cloud)

  A python library for interacting with [ArchFX Cloud](https://archfx.io) Rest API.



  When it comes to using Python packages, it is always recommened you use a Python Virtual Env. Using Python 3, you can simply do

  ```bash
  python3 -m venv  ~/.virtualenv/archfx-cloud
  source ~/.virtualenv/archfx-cloud/bin/activate
  ```

  or follow one of the many tutorials to setup Python virtual environments.

  Once you have set up a virtual, env, simply install the package with:

  ```bash
  pip install archfx_cloud
  ```

  Package is based on https://github.com/samgiles/slumber and https://github.com/iotile/python_iotile_cloud



  In a Rest API, Resources represent tables in the database. The following resources are available in **ArchFX Cloud**:

  - **account**: Represent users. A user only has access to its own user profile
  - **org**: Users belong to Organizations as members. Some of these users can act as admins for the organization.
  - **site**: Organizations contain Sites. A site usually represents a geographical location.
  - **area**: Sites can have Areas, which either represent a group of discrete manufacturing, or it is a group
  of assembly lines. Areas usually represent Buildings or a set of machines of the same type.
  - **line**: Sites or Areas can have Lines, which represent assembly lines. Lines are usually created within an area
  but do not need to. But like areas, they do need to always belong to a Site.
  - **machine**: A Machine represents the physical machine we are extracting data from. It is a virtual concept but
  is usually one to one with a machine in the factory, and has a brand, model, serial number and maybe asset number.
  - **device**: A device represent IOTile HW Taps, and/or Factory SW connectors that extract data from a Machine. a Given
  **Machine** may have multiple HW taps or even multiple SW connectors, which is one there is a one to many
  relationship between Machines and Devices
  - **stream**: Streams represent a globally unique instance of data comming from a given device (sensor).
  Streams represent the virtual data at the machine level (regardless of the device it came from). Over time,
  a given stream may come from different devices (e.g. if a device breaks and needs to be replaced).
  - **streampages**: A stream is a virtual concept that is build out of **device** data. Data on a device is
  represented by a StreamPage. A stream page is always linked to a Stream, but may have a specific start/end
  time period. A stream is therefore built out of stream pages, which may or may not come from the same device.
  - **data**: Every Stream represents the time series data. This resource can be used to access this data.



  Most of the key records in the database use a universally unique ID, in the form of an ID Slug. We borrow the term slug
  from blogging systems because we use it the same way to create unique but readable URLs.

  The following are the resources that use a globally unique ID:

  - Sites use **ps--0000-0001**
  - Areas use **pa--0000-0001**
  - Lines use **pl--0000-0001**
  - Device **d--0000-0000-0000-0001** represent device 1. Note that this is also the Serial Number for the device itself,
  and can be found on each IOTile Device. For virtual devices (SW connectors), the ID is also assigned from the same
  place. Note that all device IDs are allocated and managed by https://iotile.cloud but that should be transparent to users.
  All devices have the same `d--0000-0000` scope.
  - Machines use the same standard as devices, except that the use a non-zero scope. e.g. **d--0000-0001-0000-0001**
  - Sites, Areas, Lines, Machines and Devices can all have streams of data, but all share the same globally unique naming
  standard. All streams are named based on `<parent_type>--<parent_id>--<device/machine_id>--<variable_id>` where the variable
  is a 32bit identifier, usually following global IDs (e.g. `0000-5051` to represent `ProductReady`):
    - **ss--0000-0001--0000-0000-0000-0000--0000-5051** represents a site stream for site `ps--0000-0001`
    - **sa--0000-0001--0000-0000-0000-0000--0000-5051** represents an area stream for area `pa--0000-0001`
    - **sl--0000-0001--0000-0000-0000-0000--0000-5051** represents a line stream for line `pl--0000-0001`
    - **sl--0000-0001--0000-0000-0000-0001--0000-5051** represents a device stream for device `d--0000-0000-0000-0001` under line `pl--0000-0001`
    - **sl--0000-0001--0000-0001-0000-0001--0000-5051** represents a machine stream for machine `d--0000-0001-0000-0001` under line `pl--0000-0001`

  You can see how:

  - Slug components are separated by a ‘--’ string
  - A one or two character letter(s) represents the type of slug: 'p?', 'd', and 's?'





  The Api class is used to login and logout from the ArchFX Cloud

  Example:

  ```python
  from archfx_cloud.api.connection import Api

  c = Api('https://arch.arhfx.io')

  ok = c.login(email=args.email, password=password)
  if ok:
      

      c.logout()
  ```

  If you have a JWT token, you can skip the login and just set the token:

  ```python
  from archfx_cloud.api.connection import Api

  c = Api('https://arch.arhfx.io')

  c.set_token('big-ugly-token')
  ```

  You can use the Api itself to login and get a token:

  ```python
  from archfx_cloud.api.connection import Api

  c = Api('https://arch.arhfx.io')

  ok = c.login(email=args.email, password=password)
  if ok:
      token = c.token
      
  ```



  The `Api(domain)` can be used to access any of the APIs in https://arch.archfx.io/api/v1/

  The `Api(domain)` is generic and therefore will support any future resources supported by the ArchFX Cloud Rest API.

  ```python
  from archfx_cloud.api.connection import Api

  api = Api('https://arch.arhfx.io')
  ok = api.login(email='user@example.com', password='my.pass')



  api.org.get()


  new = api.org.post({"name": "My new Org"})


  api.org(new["slug"]).put({"about": "About Org"})

  PATCH https://arch.archfx.io/api/v1/org/{slug}/
  api.org(new["slug"]).patch({"about": "About new Org"})


  api.org(new["slug"]).get()



  api.org(new["slug"]).delete()
  ```

  You can pass arguments to any get() using

  ```python

  for org in api.org.get()['results']:
     
     
     org_sites = c.site.get(org='{0}'.format(org['slug']))

  ```

  You can also call nested resources/actions like this:

  ```python

  for org in api.machine.get()['results']:
     
     associated_devices = c.machine(org['slug']).devices.get()

  ```



  To easily handle ID slugs, use the `utils.gid` package:

  ```python
  parent = ArchFxParentSlug(5, ptype='pl)
  assert(str(parent) == 'pl--0000-0005')

  device = ArchFxDeviceSlug(10)
  assert(str(device) == 'd--0000-0000-0000-000a')


  id = ArchFxStreamSlug()
  id.from_parts(parent=parent, device=device, variable='0000-5501)
  assert(str(id) == 'sl--0000-0005--0000-0000-0000-000a--0000-5001')

  parts = id.get_parts()
  self.assertEqual(str(parts['parent']), str(parent))
  self.assertEqual(str(parts['device']), str(device))
  self.assertEqual(str(parts['variable']), '0000-5501')


  device = ArchFxDeviceSlug('000a)
  assert(str(device) == 'd--0000-0000-0000-000a')
  device = ArchFxDeviceSlug('d--000a')
  assert(str(device) == 'd--0000-0000-0000-000a')
  device = ArchFxDeviceSlug(0xa)
  assert(str(device) == 'd--0000-0000-0000-000a')
  ```



  As you can see from the examples above, every script is likely to follow the following format:

  ```python




  ```

  To make it easy to add this boilerplate code, the BaseMain can be used to follow a predefined, opinionated flow
  which basically configures the `logging` and `argsparse` python packages with a basic configuration during the
  construction. Then the `main()` method runs the following flow, where each function call can be overwritten in your
  own derived class

  ```python
     self.domain = self.get_domain()
     self.api = Api(self.domain)
     self.before_login()
     ok = self.login()
     if ok:
         self.after_login()
         self.logout()
         self.after_logout()
  ```

  An example of how to use this class is shown below:

  ```python
  class MyScript(BaseMain):

      def add_extra_args(self):
          
          self.parser.add_argument('foo', metavar='foo', type=str, help='RTFM')

      def before_login(self):
          logger.info('-----------')

      def after_login(self):
          
          do_some_real_work(self.api, self.args)

      def login(self):
          
          ok = super(MyScript, self).login()
          if ok:
              logger.info('Welcome {0}'.format(self.args.email))
          return ok

      def logout(self):
          
          super(MyScript, self).logout()
          logger.info('Goodbye!')


  if __name__ == '__main__':

      work = MyScript()
      work.main()
  ```



  The `ArchFXDataPoint` and `ArchFXFlexibleDictionaryReport` helper classes can be used to generate a Streamer Report
  compatible with ArchFX Cloud. A Streamer Report can be used to send several stream data records together.
  Using Streamer Reports have several benefits over uploading data manually using the Rest API. Apart from the efficiency
  of uploading multiple data points together, the streamer report ensures that data is not processed multiple times.
  Each record has a sequential ID which ensures that the cloud will never process data that has already been processed,
  allowing Streamer Reports to be uploaded multiple times without worrying about duplication.

  The Streamer Report uses [msgpack](https://msgpack.org) as format, which is a compressed JSON file.

  Next is a simple example for using these classes:

  ```python
  from datetime import datetime
  from io import BytesIO
  from dateutil import parser
  from archfx_cloud.api.connection import Api
  from archfx_cloud.reports.report import ArchFXDataPoint
  from archfx_cloud.reports.flexible_dictionary import ArchFXFlexibleDictionaryReport


  reading = ArchFXDataPoint(
      timestamp=parser.parse('2021-01-20T00:00:00.100000Z'),
      stream='0001-5090',
      value=2.0,
      summary_data={'foo': 5, 'bar': 'foobar'},
      raw_data=None,
      reading_id=1000
  )
  events.append(reading)
  reading = ArchFXDataPoint(
      timestamp=parser.parse('2021-01-20T00:00:00.200000+00:00'),
      stream='0001-5090',
      value=3.0,
      summary_data={'foo': 6, 'bar': 'foobar'},
      reading_id=1001
  )
  events.append(reading)


  sent_time = datetime.datetime.utcnow()
  report = ArchFXFlexibleDictionaryReport.FromReadings(
      device='d--1234',
      data=events,
      report_id=1003,
      streamer=0xff,
      sent_timestamp=sent_time
  )


  api = Api('https://arch.arhfx.io')
  ok = api.login(email=args.email, password=password)
  if ok:
      fp = ("report.mp", BytesIO(report.encode()))
      resp = api.streamer().report.upload_fp(fp=fp, timestamp=sent_time.isoformat())
  ```



  archfx_cloud requires the following modules.

  - Python 3.7+
  - requests
  - python-dateutil



  To test, run `python setup.py test` or to run coverage analysis:

  ```bash
  coverage run --source=archfx_cloud setup.py test
  coverage report -m
  ```



  To deploy to pypi:

  1. Update `version.py` with new version number
  1. Update `RELEASE.md` with description of new release
  1. Run `python setup.py test` to ensure everything is ok
  1. Commit all changes to master (PR is needed)
  1. Once everythin commited, create a new version Tag. Deployment is triggered from that:

  ```bash
  git tag -a v0.9.13 -m "v0.9.13"
  git push origin v0.9.13
  ```



  All deployments should be done using the Ci/CD process (github actions)
  but just for copleteness, this is how a manual deployments is done

  ```bash

  python setup.py test

  python setup.py sdist bdist_wheel
  twine check dist/*

  twine upload dist/*
  ```


pkgId: f9b88c6adf81aa816c33527f8501a420c35ddd3de68a09b040e9fdabac7c2fca
name: python-archicad
arch: src
version: 28.3000
epoch: 0
release: 1
summary: Python binding for the Archicad JSON command interface
url: https://archicadapi.graphisoft.com/archicadPythonPackage/archicad.html
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archicad-28.3000-1.src.rpm
checksum_type: sha256
description:
  This is the official Python binding for the Archicad JSON command interface.

  This package provides a convenient way to write simple scripts to support your Archicad workflow, e.g. by automating repetitive tasks.

  The set of available commands will increase with each release.



  * Archicad 24 beta 3 or later.
  * Python 3.7 or later (Tcl/Tk is recommended)



  * Install the package with pip
  * *Optional: Enable the experimental Python palette in Archicad*
  * Run your own scripts either from the command line or directly from ARCHICAD



  * [Reference Manual](https://archicadapi.graphisoft.com/archicadPythonPackage/archicad.html)
  * [Documentation of Archicad's new JSON interface](https://archicadapi.graphisoft.com/JSONInterfaceDocumentation/#Introduction)
  * [Official website](https://graphisoft.com/downloads/python)





  Here's an overview of the changes included in this release:
  * GetSelectedElements
      - A new parameter called `onlySupportedTypes` has been added.
          - When set to `true`, only elements with types supported by other JSON API commands will be returned.
  * GetAttributesIndices
      - A new function that provides requested indices and GUIDs for given attributes.
  * New Attribute related classes were introduced:
      1. `AttributeIndexAndGuid`
      2. `AttributeIndexAndGuidWrapperItem`
      3. `AttributeIndexAndGuidOrError`



  This release focuses primarily on maintenance, ensuring continued support for our users.

  Here's an overview of the changes included in this release:
  * New Attribute related classes were introduced and some former classes were removed.
  * CreateAttributeFolders uses a list of AttributeFolderCreationParameters instead of AttributeFolders.
  * DeleteAttributeFolders uses AttributeFolderIds instead of AttributeFolders.
  * GetAttributeFolder and GetAttributeFolderContent functions are removed.
  * GetAttributeFolders uses AttributeFolders instead of DetailedAttributeFolders.
  * MoveAttributesAndFolders uses AttributeFolderIds parameters instead of the AttributeFolders.
  * RenameAttributeFolder was renamed to RenameAttributeFolders and uses AttributeFolderRenameParameters instead of the two previous parameters.



  * Preparation for Archicad 26 release.
  * More navigator item types are handled
  * New attribute-related commands (folder handling) are introduced
  * Property handling: return info on property default values
  * Removed those attribute types which are not attributes in Archicad reality
  * Classification systems are introduced
  * Property groups are now available
  * Selected elements' identifiers can be queried



  * More properties became available. For example, the dynamic enum-typed built-in properties (like Structural Function, Position and Renovation Status) are available from AC25. Those can be retrieved and modified.



  * ExecuteAddOnCommand and IsAddOnCommandAvailable commands require command namespace instead of developerId and localId.



  * Preparation for ARCHICAD 25 release.
  * New commands were introduced.



  * Preparation for Archicad 25 release.
  * New commands were introduced.



  * An unexpected Runtime Error is fixed.



  * Beta release. Compatible with the official Archicad beta 3.
  * Doesn't compatible with earlier (preview) versions.


pkgId: a5429e8097ac31d285ca84e1d2c6af1cc3815c7b5fb433646122bb6fdf677a78
name: python-archimedean
arch: src
version: 5.9
epoch: 0
release: 1
summary: The Ultimate Archimedean CLI
url: https://pypi.org/project/archimedean/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archimedean-5.9-1.src.rpm
checksum_type: sha256
description:
  Sends email whenever there is new homework on Archie website. Can download all files from any class in CineMath. Can download any resource posted on Archie.
  Still in testing phase!



      If you do not have Python installed, go to https://www.python.org/downloads/
      Then download the latest version of Python
      After installing, open terminal and
      run 'python3 -m pip install archimedean'

      If you do have Python installed, then
      Open the terminal
      Run 'python3 -m pip install archimedean' to install



      In the terminal, first run 'archimedean login' to save your credentials

      Commands:
        'archimedean homework' prints current homework and due dates to the command line
        'archimedean cinemath' downloads all lessons from a class in CineMath
        'archimedean email' will send you an email every time there is new homework on Archie
        'archimedean birthdays' will show all upcoming birthdays for other students
        'archimedean resources' will show links for resources for a specified class on Archie



      If you have any questions, feel free to email me at:
      daniel.miami2005@gmail.com



      The GitHub repository for this project is at https://github.com/BananaApache/archimedean


pkgId: b0b9525a5f84549cea2e5a306c013038c9881831d4b2e8387781aaa81365e065
name: python-archimedes-python-client
arch: src
version: 4.20.3
epoch: 0
release: 1
summary: The Python library for Archimedes
url: https://pypi.org/project/archimedes-python-client/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archimedes-python-client-4.20.3-1.src.rpm
checksum_type: sha256
description:
  `archimedes` is the python sdk for accessing Optimeering data. This document outlines the setup of
  environment, authentication and general usage of the python client to fetch RK within day data using python.



  We will be using [venv](https://docs.python.org/3/library/venv.html) to manage the virtual environment in this example.



  ```bash
  python3 -m venv .venv
  ```

  This will create a directory named `.venv` where all the dependencies will be installed.



  ```bash
  source ./.venv/bin/activate # linux/macOS
  .venv\Scripts\activate.bat # Windows cmd
  .\.venv\Scripts\Activate.ps1 # Windows PowerShell
  ```



  ```bash
  python3 -m pip install archimedes-python-client
  ```



  **For local development:**

  For local development, the python client can use user authentication. The users are can be authenticated using the
  archimedes command line tool `arcl`.

  ```bash
  python3 -m pip install arcl

  arcl auth login # then, follow the instructions to login with your Microsoft account
  ```

  Once the user is logged in, the archimedes login information will be stored in your `~/.archimedes` directory and all
  the scripts and applications running as the same user are able to authenticate to the API automatically when using the
  `archimedes-python-client`.

  **For deployed applications:**

  The python client uses the following fields in environment variable for authentication of the client.

  1. `AZURE_AD_TENANT_ID`  **Provided by Optimeering AS**
  2. `AZURE_AD_APP_ID` **Provided by Optimeering AS**
  3. `AZURE_AD_APP_CLIENT_CREDENTIAL` **Provided by Optimeering AS**
  4. `USE_APP_AUTHENTICATION` **Set to True**

  As long as these variables have been set up as environment variables, any python script that invokes methods in
  `archimedes` will automatically use the values in the environment variables for authentication.



  Below is a code sample that invokes an `archimedes` method.

  ```python

  import archimedes









  data = archimedes.rk_within_day.directions(
      start="2023-01-01 00:00:00+0000",
      price_area="NO1",
      end="2023-01-01 01:00:00+0000",
      ref_dt="2022-12-31 23:00:00+0000"
  )
  print(data)
  ```

  The sample code prints the RK within day directions probability for provided constraints to the console.


pkgId: bc4d9f10cce00a06ab2877c36a3655a40207e545be22978cfbc8203dd29e6b31
name: python-archinfo
arch: src
version: 9.2.122
epoch: 0
release: 1
summary: Classes with architecture-specific information useful to other projects.
url: https://github.com/angr/archinfo
rpm_license: BSD-2-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archinfo-9.2.122-1.src.rpm
checksum_type: sha256
description:
  [![Latest Release](https://img.shields.io/pypi/v/archinfo.svg)](https://pypi.python.org/pypi/archinfo/)
  [![Python Version](https://img.shields.io/pypi/pyversions/archinfo)](https://pypi.python.org/pypi/archinfo/)
  [![PyPI Statistics](https://img.shields.io/pypi/dm/archinfo.svg)](https://pypistats.org/packages/archinfo)
  [![License](https://img.shields.io/github/license/angr/archinfo.svg)](https://github.com/angr/archinfo/blob/master/LICENSE)

  archinfo is a collection of classes that contain architecture-specific information.
  It is useful for cross-architecture tools (such as pyvex).


  Project repository: https://github.com/angr/archinfo

  Documentation: https://api.angr.io/projects/archinfo/en/latest/


pkgId: 6c77cfff8b460587396a1da2e0908a35a02a0b211d80d8ea3d66c46cffb09a0d
name: python-architect
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: A set of tools which enhances ORMs written in Python with more features
url: https://github.com/maxtepkeev/architect
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-architect-0.6.0-1.src.rpm
checksum_type: sha256
description:
  Architect is a set of tools which enhances ORMs written in Python with more features and simplifies
  different database related complex tasks.


pkgId: 8c843be3ec5e9984bf8eafde6380e93df7d39cc181dd0462d3bda0e2b25a6523
name: python-architect-py
arch: src
version: 1.5.1
epoch: 0
release: 1
summary: Client library for the Architect trading platform.
url: https://pypi.org/project/architect-py/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-architect-py-1.5.1-1.src.rpm
checksum_type: sha256
description:
  ```python
  import asyncio
  from architect_py.async_client import AsyncClient


  async def main():
      c = AsyncClient(
          host="<your installation domain>",
          api_key="<api key>",
          api_secret="<api secret>"
      )
      print(await c.execute("query { me { userId email } }"))
      s = c.subscribe_trades("BTC Crypto/USD*COINBASE/DIRECT")
      async for trade in s:
          print(trade)


  asyncio.run(main())
  ```



  Clone this repository to run examples in the `examples` directory.  This package
  uses poetry for dependency management.  To enter a poetry virtual environment, make
  sure you have [poetry](https://python-poetry.org/docs/) installed and run the
  following from the repository root.

  ```bash
  poetry shell
  poetry install --sync

  export ARCHITECT_HOST="<your installation domain>"
  export ARCHITECT_API_KEY="<api key>"
  export ARCHITECT_API_SECRET="<api secret>"

  python -m examples.trades
  ```

  You can exit the poetry shell by running `exit`.  Environment variables set
  within the shell are not persisted.



  `poetry run ariadne-codegen --config ariadne-codegen.toml`
  `poetry run ariadne-codegen --config ariadne-codegen.async.toml`


pkgId: bd43374fe19acedef0434c1b8a815f0a77cd37305ddd2328714e9ccf8796d73d
name: python-architecture
arch: src
version: 0.1.4
epoch: 0
release: 1
description: *Happy Coding with Architecture! 🚀*
url: https://pypi.org/project/architecture/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-architecture-0.1.4-1.src.rpm
checksum_type: sha256
summary:
  Architecture is a lightweight, comprehensive framework that empowers developers to create robust, maintainable applications. By adhering to clean architecture principles and domain-driven design (DDD) patterns, weavearc provides the foundational building blocks needed for scalable, flexible, and easily testable backends. Simplify the complex and build with confidence across any architecture.


pkgId: c6f77d769e9c3f105aeb957d1d24d75899bd786f0e30a47e49b8c477c16e76c7
name: python-archive-path
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: A package to provide pathlib like access to zip & tar archives.
url: https://github.com/aiidateam/archive-path
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archive-path-0.4.2-1.src.rpm
checksum_type: sha256
description:
  [![Build Status][ci-badge]][ci-link]
  [![codecov.io][cov-badge]][cov-link]
  [![PyPI version][pypi-badge]][pypi-link]
  [![Conda Version][conda-badge]][conda-link]

  A package to provide pathlib like access to zip & tar archives.



  ```console
  $ pip install archive-path
  ```



  For reading zip (`ZipPath`) or tar (`TarPath`) files:

  ```python
  from archive_path import TarPath, ZipPath

  path = TarPath("path/to/file.tar.gz", mode="r:gz")

  sub_path = path / "folder" / "file.txt"
  assert sub_path.filepath == "path/to/file.tar.gz"
  assert sub_path.at == "folder/file.txt"
  assert sub_path.exists() and sub_path.is_file()
  assert sub_path.parent.is_dir()
  content = sub_path.read_text()

  for sub_path in path.iterdir():
      print(sub_path)
  ```

  For writing files, you should use within a context manager, or directly call the `close` method:

  ```python
  with TarPath("path/to/file.tar.gz", mode="w:gz") as path:

      (path / "new_file.txt").write_text("hallo world")
      
      (path / "other_file.txt").putfile("path/to/external_file.txt")
      (path / "other_folder").puttree("path/to/external_folder", pattern="**/*")
  ```

  Note that archive formats do not allow to overwrite existing files (they will raise a `FileExistsError`).

  For performant access to single files:

  ```python
  from archive_path import read_file_in_tar, read_file_in_zip

  content = read_file_in_tar("path/to/file.tar.gz", "file.txt", encoding="utf8")
  ```

  These methods allow for faster access to files (using less RAM) in archives containing 1000's of files.
  This is because, the archive's file index is only read until the path is found (discarding non-matches),
  rather than the standard `tarfile`/`zipfile` approach that is to read the entire index into memory first.



  Paths within the archives are **always** read and written as being `/` delimited.
  This means that the package works on Windows,
  but will not be compatible with archives written outside this package with `\\` path delimiters.



  See [CONTRIBUTING.md](CONTRIBUTING.md) for details on how to contribute to this package.

  [ci-badge]: https://github.com/aiidateam/archive-path/workflows/CI/badge.svg?branch=main
  [ci-link]: https://github.com/aiidateam/archive-path/actions?query=workflow%3ACI+branch%3Amain+event%3Apush
  [conda-badge]: https://img.shields.io/conda/vn/conda-forge/archive-path.svg
  [conda-link]: https://anaconda.org/conda-forge/archive-path
  [cov-badge]: https://codecov.io/gh/aiidateam/archive-path/branch/main/graph/badge.svg
  [cov-link]: https://codecov.io/gh/aiidateam/archive-path
  [pypi-badge]: https://img.shields.io/pypi/v/archive-path.svg
  [pypi-link]: https://pypi.org/project/archive-path


pkgId: c6b66f4e2635e734bb4d6407fee834d5cf9f259675eed432eae352fb7d38e6ee
name: python-archivefile
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Unified interface for tar, zip, sevenzip, and rar files
url: https://archivefile.ravencentric.cc
rpm_license: Unlicense
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archivefile-1.0.0-1.src.rpm
checksum_type: sha256
description:
  <br/>
  <p align="center">
    <a href="https://github.com/Ravencentric/archivefile">
      <img src="https://raw.githubusercontent.com/Ravencentric/archivefile/main/docs/assets/logo.png" alt="Logo" width="400">
    </a>
    <p align="center">
      Unified interface for tar, zip, sevenzip, and rar files
    </p>
  </p>

  <div align="center">

  [![PyPI - Version](https://img.shields.io/pypi/v/archivefile?link=https%3A%2F%2Fpypi.org%2Fproject%2Farchivefile%2F)](https://pypi.org/project/archivefile/)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/archivefile)
  ![License](https://img.shields.io/github/license/Ravencentric/archivefile)
  ![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)
  ![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)

  ![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/Ravencentric/archivefile/release.yml)
  ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/ravencentric/archivefile/test.yml?label=tests)
  [![codecov](https://codecov.io/gh/Ravencentric/archivefile/graph/badge.svg?token=B45ODO7TEY)](https://codecov.io/gh/Ravencentric/archivefile)

  </div>



  * [About](#about)
  * [Installation](#installation)
  * [Docs](#docs)
  * [License](#license)



  `archivefile` is a wrapper around [`tarfile`](https://docs.python.org/3/library/tarfile.html), [`zipfile`](https://docs.python.org/3/library/zipfile.html), [`py7zr`](https://github.com/miurahr/py7zr), and [`rarfile`](https://github.com/markokr/rarfile).

  The above libraries are excellent when you are dealing with a single archive format but things quickly get annoying when you have a bunch of mixed archives such as `.zip`, `.7z`, `.cbr`, `.tar.gz`, etc because each library has a slightly different syntax and quirks which you need to deal with.

  `archivefile` wraps the common methods from the above libraries to provide a unified interface that takes care of said differences under the hood. However, it's not as powerful as the libraries it wraps due to lack of support for features that are unique to a specific archive format and library.



  `archivefile` is available on [PyPI](https://pypi.org/project/archivefile/), so you can simply use [pip](https://github.com/pypa/pip) to install it.

  1. Without optional dependencies:

      ```sh
      pip install archivefile
      ```

  2. With optional dependencies:

      - Required for [`ArchiveFile.print_tree()`](https://archivefile.ravencentric.cc/api-reference/archivefile/#archivefile.ArchiveFile.print_tree)

          ```sh
          pip install archivefile[bigtree]
          ```

      - Required for [`ArchiveFile.print_table()`](https://archivefile.ravencentric.cc/api-reference/archivefile/#archivefile.ArchiveFile.print_table)

          ```sh
          pip install archivefile[rich]
          ```

  3. With all dependencies:

      ```sh
      pip install archivefile[all]
      ```



  `archivefile` offers a single class called `ArchiveFile` to deal with various archive formats. Some examples are given below:

  ```py
  from archivefile import ArchiveFile

  with ArchiveFile("../source.zip") as archive:
      archive.extract("pyproject.toml", destination="./dest/") # Extract a single member by it's name
      archive.extractall(destination="./dest/") # Extract all members
      archive.get_member("pyproject.toml")  # Get the ArchiveMember object for the member by it's name
      archive.get_members()  # Retrieve all members from the archive as a generator of ArchiveMember objects
      archive.get_names()  # Retrieve names of all members in the archive as a tuple of strings
      archive.read_bytes("pyproject.toml") # Read the contents of the member as bytes
      archive.read_text("pyproject.toml")  # Read the contents of the member as text
      archive.print_tree()  # Print the contents of the archive as a tree.
      archive.print_table()  # Print the contents of the archive as a table.

  with ArchiveFile("../source.zip", "w") as archive:
      archive.write("foo.txt", arcname="bar.txt")  # Write foo.txt to the archive as bar.txt
      archive.writeall("./src/") # Recursively write the ./src/ directory to the archive
      archive.write_text("spam and eggs", arcname="recipe.txt") # Write a string to the archive as recipe.txt
      archive.write_bytes(b"0101001010100101", arcname="terminator.py")  # Write bytes to the archive as terminator.py
  ```



  Checkout the complete documentation [here](https://archivefile.ravencentric.cc/).



  Distributed under the [Unlicense](https://choosealicense.com/licenses/unlicense/) License. See [UNLICENSE](https://github.com/Ravencentric/archivefile/blob/main/UNLICENSE) for more information.


pkgId: 6bdbd6457b9846626bada2229e6b0c185fb32cee6d967d554b2dcd148af12b8f
name: python-archivista
arch: src
version: 0.4.6
epoch: 0
release: 1
summary: Transformador de contenidos para Pelican
url: https://github.com/guivaloz/archivista
rpm_license: GNU Affero General Public License v3 or later (AGPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archivista-0.4.6-1.src.rpm
checksum_type: sha256
description:
  Transformador de contenidos a la estructura y metadatos que requiere **Pelican;**
  así puede mantenerse un depósito _sencillo_ en la nube con directorios y archivos
  para generar los directorios y archivos en _content_.

  Ofrece la ventaja de determinar los metadatos a falta de éstos; por ejemplo,
  si no se tiene un _Title_ se toma el nombre del archivo MD. También destaca por
  crear índices _automáticos_ cuando se colocan documentos PDF o páginas MD en directorios.

  Además identifica archivos _descargables_ como PDF, XLSX, DOCX, etc. El propósito de esto
  es que el conjunto de páginas, imágenes y archivos web (JPG, PNG, GIF, etc.)
  se suban a un servicio de hospedaje gratuito (por ejemplo GitHub) y lo más pesado
  a un _almacén frío_ como **Google Storage**.



  - 0.4.6 Metadatos JavaScripts Stylesheets
  - 0.4.5 Mejor configuración y breadcrumb se puede deshabilitar
  - 0.4.4 Marca error si la rama no está configurada
  - 0.4.3 Metadato "Preview" para imágenes previas de artículos
  - 0.4.2 Cuando hay un elemento se omite el breadcrumb
  - 0.4.1 Breadcrumb
  - 0.3.8 Los subdirectorios con fecha la pueden tener en cualquier parte
  - 0.3.7 Los subdirectorios con fecha se ordenan del más reciente al más pasado
  - 0.3.6 Al crear los mensajes son cuantitativos
  - 0.3.5 Orden ascendente en subdirectorios e índices
  - 0.3.4 Descarta metadatos desconocidos en los archivos md
  - 0.3.3 Ya no necesita el archivo CSV, ahora puede obtener metadatos de los archivos md; también algunas configuraciones son opcionales
  - 0.3.2 Comando con dos órdenes (mostrar y crear) y puede eliminar lo previo en content
  - 0.3.1 Configuración en un archivo externo settings.ini
  - 0.2.0 Obtener los metadatos desde un archivo CSV
  - 0.1.0 Primeros experimentos



  Debe crear un archivo `settings.ini` con las opciones

  - almacen_frio: La ruta al depósito Google Storage donde van a estar los archivos descargables
  - descargables_extensiones:
  - eliminar_content_rama:
  - fecha_por_defecto:
  - imagenes_extensiones:
  - indice_maximo_elementos_como_encabezado:
  - nextcloud_ruta:


pkgId: 2f867f52fe2b57cde8b881ca9c5450deb0993fe65d6403e372062db171be6fba
name: python-archivy
arch: src
version: 1.7.7
epoch: 0
release: 1
summary: Minimalist knowledge base focused on digital preservation and building your second brain.
url: https://github.com/archivy/archivy
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archivy-1.7.7-1.src.rpm
checksum_type: sha256
description:
  ![logo](docs/img/logo.png)



  Archivy is a self-hostable knowledge repository that allows you to learn and retain information in your own personal and extensible wiki.

  Features:

  - If you add bookmarks, their web-pages contents' will be saved to ensure that you will **always** have access to it, following the idea of [digital preservation](https://jeffhuang.com/designed_to_last/). Archivy is also easily integrated with other services and your online accounts.
  - Knowledge base organization with bidirectional links between notes, and embedded tags.
  - Everything is a file! For ease of access and editing, all the content is stored in extended markdown files with yaml front matter. This format supports footnotes, LaTeX math rendering, syntax highlighting and more.
  - Extensible plugin system and API for power users to take control of their knowledge process
  - [syncing options](https://github.com/archivy/archivy-git)
  - Powerful and advanced search.
  - Image upload


  [demo video](https://www.uzpg.me/assets/images/archivy.mov)

  [Roadmap](https://github.com/archivy/archivy/issues/74#issuecomment-764828063)

  Upcoming:

  - Annotations
  - Multi User System with permission setup.




  Install archivy with `pip install archivy`. Other installations methods are listed [here](https://archivy.github.io/install), including Docker.

  Run the `archivy init` command to setup you installation.

  Then run this and enter a password to create a new user:

  ```bash
  $ archivy create-admin <username>
  ```

  Finally, execute `archivy run` to serve the app. You can open it at https://localhost:5000 and login with the credentials you entered before.

  You can then use archivy to create notes, bookmarks and then organize and store information.

  See the [official docs](https://archivy.github.io) for information on other installation methods.



  Archivy is dedicated to building **open and quality knowledge base software** through collaboration and community discussion.

  To get news and updates on Archivy and its development, you can [watch the archivy repository](https://github.com/archivy/archivy) or follow [@uzpg_ on Twitter](https://twitter.com/uzpg_).

  You can interact with us through the [issue board](https://github.com/archivy/archivy/issues) and the more casual [discord server](https://discord.gg/uQsqyxB).

  Note: If you're interested in the applications of AI to knowledge management, we're also working on this with [Espial](https://github.com/Uzay-G/espial).


pkgId: 794b053a661a261f673cedae3d910836655bd3be64fa744145a6cfaf886e2a86
name: python-archon-ai
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/archon-ai/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archon-ai-0.1.4-1.src.rpm
checksum_type: sha256
description:
  This repository provides a minified version of the accompanying code for [Archon: An Architecture Search Framework for Inference-Time Techniques](https://arxiv.org/abs/2409.15254)

  Inference-time techniques allow us to bolster the strengths of existing LMs by utilizing multiple sample calls and multiple LMs to increase system performance for a given task.
  Archon provides a modular framework for combining different inference-time techniques and LMs with just a JSON config file. Check out our [Quick Start](#quick-start) guide to get started. This repo specifically support completions without benchmarks.

  ![Archon Overview Diagram](readme_assets/archon_itas_diagram.svg)


  - [Installation](#installation)
      - [Python Package](#python-package)
      - [Running Locally](#running-locally)
  - [Archon Overview](#archon-overview)
  - [Quick Start](#quick-start)
  - [Tutorials/Examples](#tutorialsexamples)
  - [gen_answers.py and Benchmarks](#gen_answerspy-and-benchmarks)
      - [Add Your Own Benchmark](#add-your-own-benchmark)
  - [Key Handling](#key-handling)




  Archon is publicly available for use at [here](https://pypi.org/project/archon-ai/).
  ```
  pip install archon-ai
  ```
  A tutorial on how to use it can be found [here](https://colab.research.google.com/drive/1Hw8zNrTJdJ5bIJPtEljQ-UxC3n6udp2_?usp=sharing)


  Alternatively, you can use Archon directly from this repository. This is the most up to date and offers the most flexibility working with our codebase

  ```shell
  git clone https://github.com/ScalingIntelligence/Archon.git
  git submodule init
  git submodule update
  ```

  We recommend using our environment that can be initialized with:
  ```
  conda env create -f archon_env.yml
  conda activate archon_env
  pip install -r requirements.txt
  ````

  We recommend you work within the `archon/` directory.
  Archon can be instantiated via the [Archon](https://github.com/ScalingIntelligence/Archon/blob/main/archon/archon.py#L176) class in `archon.py`. Get started by cloning the repository and navigating to our [quickstart.py](src/quickstart.py) or creating your own starter file that imports our Archon class as shown below:
  ```python
  from archon.completions import Archon
  ```

  Our Archon codebase provides users with the ability to run Archon configurations. We highly recommend reading our research paper [here](https://arxiv.org/abs/2409.15254).

  At the moment, we provide support for these inference times techniques: `generator`, `fuser`, `critic`, `ranker`, `verifier`, `unit_test_generator`, `unit_test_evaluator`. Their prompts can be found [here](src/archon/completions/components/prompts.py). As well as the ability to [add your own components](#tutorialsexamples).

  We also provide these API Access points that can be used in Archon configurations: `Together_API`, `OpenAI_API`, `Anthropic_API`, `Groq_API`, `Google_API`, `tgi`, `Bedrock_API`. You can also [add your own generators/endpoints](#tutorialsexamples).


  This colab notebook is a tutorial on how to use the Archon python package.

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

  Archon works by taking in a config file in JSON format that specifies the architecture you want to run and its available parameters.
  Say I want to ask a compound GPT 4o system a question and output a singular response. We want to sample gpt-4o 10 times, rank the top 5 responses, and then fuse for a final response. We can create a config that looks like this:
  ```
  archon_gpt_config = {
      "name": "archon-gpt-multi-model",
      "layers": [
          [
              {
                  "type": "generator",
                  "model": "gpt-4o",
                  "model_type": "OpenAI_API",
                  "top_k": 1,
                  "temperature": 0.7,
                  "max_tokens": 2048,
                  "samples": 10
              }
          ],
          [
              {
                  "type": "ranker",
                  "model": "gpt-4o",
                  "model_type": "OpenAI_API",
                  "top_k": 5,
                  "temperature": 0.7,
                  "max_tokens": 2048,
              }
          ],
          [
              {
                  "type": "fuser",
                  "model": "gpt-4o",
                  "model_type": "OpenAI_API",
                  "temperature": 0.7,
                  "max_tokens": 2048,
                  "samples": 1
              }
          ]
      ]
  }
  ```
  To generate a response:
  ```python

  archon = Archon(archon_gpt_config)

  testing_instruction = [{"role": "user", "content": "How do I make a cake?"}]

  response = archon.generate(testing_instruction)

  print(response)
  ```
  A full local example can be seen in our [quickstart.py](src/quickstart.py) file or [quickstart colab notebook](https://colab.research.google.com/drive/1DH-vsm6aLxoaIPqs9xFYOBj_n6NFKEPm?usp=sharing).


  To fully take advantage of what Archon has to offer, we recommend you take a look at our tutorials/examples.

  |  **Tutorial** | **Link** | **Description** |
  | ------------- |  -------------  |  -------------  |
  | [**Archon Research Paper (Link)**](https://arxiv.org/abs/2409.15254) | [Open Link](https://arxiv.org/abs/2409.15254)  | The research paper for "Archon: An Architecture Search Framework for Inference-Time Techniques". We recommend you start here to understand what Archon is, how our components work, how Archon works as a framework, how Inference-Time Architecture Search (ITAS) leverages Archon to maximize generation quality for a wide range of tasks, and more. |
  |   [**Archon Tutorial (Colab)**](https://colab.research.google.com/drive/1Hw8zNrTJdJ5bIJPtEljQ-UxC3n6udp2_?usp=sharing) | [<img align="center" src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab" />](https://colab.research.google.com/drive/1Hw8zNrTJdJ5bIJPtEljQ-UxC3n6udp2_?usp=sharing) | A more in-depth tutorial on Archon. It goes into the set-up, its components, and examples across different tasks. Highly recommend starting here.|
  | [**Quick Start (File)**](src/quickstart.py) | [<img align="center" src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab" />](https://colab.research.google.com/drive/1DH-vsm6aLxoaIPqs9xFYOBj_n6NFKEPm?usp=sharing)  |  Introduces Archon and how to create and use a compound Archon configuration of gpt-4o models. |
  |   [**Single Model Query (Config)**](src/archon/configs/individual_models/gpt-4o-2024-05-13.json) | [<img align="center" src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab" />](https://colab.research.google.com/drive/1Y9qg4DDQs8RK-VXSEj9jZaK-fAUfTbFM?usp=sharing) | A single gpt-4o model call. |
  |   [**Custom Components (Colab)**](https://colab.research.google.com/drive/11h-uL2D7oFiSu6HdQIHlf_xDyRDOy56m?usp=sharing) | [<img align="center" src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab" />](https://colab.research.google.com/drive/11h-uL2D7oFiSu6HdQIHlf_xDyRDOy56m?usp=sharing) | We offer support on adding your own components apart from the supported ones (generation, fusion, ranking, etc). The colab notebook will show you how to create a component, add it to your configs, and add it to Archon with add_component. Furthermore, you can pass a custom state between components, allowing you to have multiple custom components that can send information between eachother.|
  |   [**Custom Generator/Endpoint (Colab)**](https://colab.research.google.com/drive/1D1Mecl1jJNRY875ThLGJZupRRQC53lk3?usp=sharing) | [<img align="center" src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab" />](https://colab.research.google.com/drive/1D1Mecl1jJNRY875ThLGJZupRRQC53lk3?usp=sharing) | We offer support to add your own generator if you need a custom access point or need more than the ones provided (Together, OpenAI, etc). The colab notebook will show you how to add a custom endpoint. Here you will see how to create a generator function, add it to your configs, and add it to Archon with add_generator.|
  |   [**Improving GPT 4o using Archon (Config)**](src/archon/configs/archon-gpt-4o-sample_10_then_rank_top_5_then_critic_then_fuse.json) | [Open Config](src/archon/configs/archon-gpt-4o-sample_10_then_rank_top_5_then_critic_then_fuse.json) | An Archon configuration which uses multiple gpt-4o calls to produce higher quality result compared to a single call of gpt-4o|
  | [**Open-sourced Archon to outperform GPT 4o (Config)**](src/archon/configs/archon-70Bx8_1_samples_then_critic_then_fuser_with_Qwen2_72B.json) | [Open Config](src/archon/configs/archon-70Bx8_1_samples_then_critic_then_fuser_with_Qwen2_72B.json) | An Archon configuration which uses only open sourced LLMs that would produce higher quality results compared to a single call of gpt-4o|
  |[**Advanced Multi-Model Setup (Colab)**](https://colab.research.google.com/drive/1LBFIi_IRXvQ6m_z0Fjjer8XdyZPdUN0b?usp=sharing) | [<img align="center" src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab" />](https://colab.research.google.com/drive/1LBFIi_IRXvQ6m_z0Fjjer8XdyZPdUN0b?usp=sharing) | Archon config that showcases multiple layers of generations, critics, ranking, and fusing.|




  We provide the script [gen_answers.py](src/archon/completions/gen_answers.py) so users can generate answers for supported benchmarks. We recommend you open and understand the file and its arguments.

  We provide seperate READMEs for their respective usage and evaluation as seen with [MT Bench](src/archon/benchmarks/mt_bench/README.md), [Arena-Hard-Auto](src/archon/benchmarks/arena_hard_auto/README.md), [AlpacaEval](src/archon/benchmarks/alpaca_eval/README.md), [MixEval](src/archon/benchmarks/mix_eval/README.md), [MATH](src/archon/benchmarks/math/README.md), [CodeContests](src/archon/benchmarks/code_contests/README.md), [GSM8K](src/archon/benchmarks/gsm8k/README.md), and more. A complete list and their implmentation can be found at [benchmarks.py](src/archon/benchmarks/benchmarks.py).

  Here is an example on how to use gen_answers.py for running your config against ArenaHardAuto. <br>
  We recommend you run all files as python modules with the -m flag and out of the src/ directory:
  ```python

  python3 -m archon.completions.gen_answers --benchmark arena_hard_auto --config <your-config-file>.json  --parallel 32
  ```
  This will run the model structure specified in your config file against the question set specified under the ArenaHardAuto class and output the responses in `.jsonl` format to the `src/outputs/arena_hard_auto/model_answer/` folder.


  To add your benchmark, you must edit the benchmarks.py file and add your benchmark class. The 'Benchmark' class can be used as a base class for interfacing between gen_answers.py and your benchmark. Lastly, make sure to add your evaluation to 'BENCHMARK_CLASSES' so it can be used as an argument in gen_answers.py


  Archon supports a couple different ways of setting your API Keys:


  Archon uses [python-dotenv](https://pypi.org/project/python-dotenv/) to load environment variables from a `.env` file. Create a `.env` file at the root of your repo with your api keys.
  ```
  export ANTHROPIC_API_KEY=<your_api_key>
  export OPENAI_API_KEY=<your_api_key>
  export TOGETHER_API_KEY=<your_api_key>
  export TOGETHER_API_KEY_2=<your_api_key>
  export TOGETHER_API_KEY_3=<your_api_key>
  ```
  The numbers at the end of the api keys are an example of how setup a `.env` file to take advantage of Archon's [key swapping](#key-swapping) feature.


  You can pass a JSON file path or a dictionary that holds your keys. An example of the expected file/dictionary format is seen in [api_keys.json](api_keys.json). For example. you would initialize Archon with:
  ```python
  archon = Archon(config, "path_to_keys/file.json")
  ```
  *Warning: FastChat will not work with just this approach and would require having api keys set as an environment variable. There may be other benchmarks that function this way which is why option 1 is preferred.*


  Instead of passing in a path to a JSON file, you can directly pass in a dictionary object with the same structure as the provided example [api_keys.json](api_keys.json).
  ```python
  keys_dict = {...}
  archon = Archon(config, keys_dict)
  ```

  Archon has a built-in system that swaps through your keys if you hit a rate limit. We found this helpful when making an extensive number of inference calls. The `_<number>` suffix for the API keys specified in your `.env` file denote the order the keys are tried. Essentially, Archon will use the first key (with no number at the end) until a rate limit is hit and then switch to `API_KEY_2` if it's available. This process repeats as Archon cycles through your available keys. The process works similarly for the dictionary/JSON approach using the keys stored in each key-list pair.


  ```bibtex
  @misc{saadfalcon2024archonarchitecturesearchframework,
        title={Archon: An Architecture Search Framework for Inference-Time Techniques},
        author={Jon Saad-Falcon and Adrian Gamarra Lafuente and Shlok Natarajan and Nahum Maru and Hristo Todorov and Etash Guha and E. Kelly Buchanan and Mayee Chen and Neel Guha and Christopher Ré and Azalia Mirhoseini},
        year={2024},
        eprint={2409.15254},
        archivePrefix={arXiv},
        primaryClass={cs.LG},
        url={https://arxiv.org/abs/2409.15254},
  }
  ```


pkgId: 268bef9f2aa21910fdeccedb668a76991e24fac8bec295b9b75bf72edb6ce293
name: python-archs4py
arch: src
version: 0.2.19
epoch: 0
release: 1
summary: ARCHS4 Python package supporting data loading and data queries.
url: https://github.com/maayanlab/archs4py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archs4py-0.2.19-1.src.rpm
checksum_type: sha256
description:
  <img title="archs4py" alt="archs4py" src="https://user-images.githubusercontent.com/32603869/243101679-c5147d56-fce0-4498-9577-a300df7d6dce.png">



  Official ARCHS4 companion package. This package is a wrapper for basic H5 commands performed on the ARCHS4 data files. Some of the data access is optimized for specific query strategies and should make this implementation faster than manually querying the data. The package supports automated file download, mutithreading, and some convenience functions such as data normalization.

  ARCHS4py also supports the ARCHS4 alignment pipeline. When aligning FASTQ files using ARCHS4py gene and transcript counts will be compatible with the preprocessed ARCHS4 samples.

  [Installation](#installation) | [Download H5 Files](#usage) | [List H5 Contents](#list-data-fields-in-h5) | [Extract Counts](#data-access) | [Extract Meta Data](#meta-data) | [Normalize Samples](#normalizing-data) | [Filter Genes](#filter-genes-with-low-expression) | [Aggregate Duplicate Genes](#aggregate-duplicate-genes) | [FASTQ Alignment](#sequence-alignment) | [Versions](#list-versions)



  ARCHS4 data is regularly updated to include publically available gene expression samples from RNA-seq. ARCHS4 processes the major platforms for human and mouse. As of 6/2023 ARCHS4 encompasses more than 1.5 million RNA-seq samples. All samples in ARCHS4 are homogeniously processed. ARCHS4 does currently not decern whether samples are bulk or single-cell and purely crawls GEO. Since samples are not always correctly annotated as single cell ARCHS4 uses a machine learning approach to predict single-cell samples and associated a singlecellprobability to each sample. Samples with a value larger than 0.5 can be removed from the queries if needed.



  The python package can be directly installed from this GitHub repository using the following command (pip or pip3 depending on system setup)

  ```
  pip3 install archs4py
  ```






  The data is stored in large HDF5 files which first need to be downloaded. HDF5 stores matrix information in a compressed datastructure that allows efficient data access to slices of the data. There are separate files for `human` and `mouse` data. The supported files are `gene counts` and `transcript counts`. As of 6/2023 the files are larger than 30GB and depending on the network speed will take some time to download.

  ```python
  import archs4py as a4

  file_path = a4.download.counts("human", path="", version="latest")
  ```



  The H5 files contain data and meta data information. To list the contents of ARCHS4 H5 files use the built in `ls` function.

  ```python
  import archs4py as a4

  file = "human_gene_v2.4.h5"
  a4.ls(file)
  ```



  archs4py supports several ways to load gene expression data. When querying ARCHS4 be aware that when loading too many samples the system might run out of memory. (e.g. the meta data search term is very broad). In most cases loading several thousand samples at the same time should be no problem. To find relevant samples there are 5 main functions in the `archs4py.data` module. A function to extract N random samples `archs4py.data.rand()`, a function to extract samples by index `archs4py.data.index()`, a function to extract samples based on meta data search `archs4py.data.meta()`, a function to extract samples based on a list of geo accessions `archs4py.data.samples()` and lastly a function to extract all samples belonging to a series `archs4.data.series()`.

  <span id="#extract-counts"></span>



  To extract a random gene expression matrix use the `archs4py.data.rand()` function. The function will return a pandas dataframe with samples as columns and genes as rows.

  ```python
  import archs4py as a4


  file = "human_gene_v2.4.h5"


  rand_counts = a4.data.rand(file, 100, remove_sc=True)

  ```



  Extract samples based on their index positions in the H5 file.

  ```python
  import archs4py as a4


  file = "human_gene_v2.4.h5"


  pos_counts = a4.data.index(file, [0,1,2,3,4])

  ```



  The ARCHS4 H5 file contains all meta data of samples. Using meta data search all matching samples can be extracted with the use of search terms. There is also an `archs4py.meta` module that will only return meta data. Meta data fields to be returned can be specified `meta_fields=["geo_accession", "series_id", "characteristics_ch1", "extract_protocol_ch1", "source_name_ch1", "title"]`

  ```python
  import archs4py as a4


  file = "human_gene_v2.4.h5"


  meta_counts = a4.data.meta(file, "myoblast", remove_sc=True)

  ```



  Samples can directly be downloaded by providing a list of GSM IDs. Samples not contained in ARCHS4 will be ignored.

  ```python
  import archs4py as a4


  file = "human_gene_v2.4.h5"


  sample_counts = a4.data.samples(file, ["GSM1158284","GSM1482938","GSM1562817"])

  ```



  To download all samples of a GEO series for example `GSE64016` use the series function.

  ```python
  import archs4py as a4


  file = "human_gene_v2.4.h5"


  series_counts = a4.data.series(file, "GSE64016")

  ```



  <span id="#extract-meta"></span>

  Additinally to the data module archs4py also supports the extraction of meta data. It supports similar endpoints to the `archs4.data` module. Meta data fields can be specified with: `meta_fields=["geo_accession", "series_id", "characteristics_ch1", "extract_protocol_ch1", "source_name_ch1", "title"]`

  ```python
  import archs4py as a4


  file = "human_gene_v2.4.h5"


  meta_meta = a4.meta.meta(file, "myoblast", meta_fields=["characteristics_ch1", "source_name_ch1"])


  sample_meta = a4.meta.samples(file, ["GSM1158284","GSM1482938","GSM1562817"])


  series_meta = a4.meta.series(file, "GSE64016")


  all_samples = a4.meta.field(file, "geo_accession")
  all_symbols = a4.meta.field(file, "symbol")
  ```


  <span id="#normalize"></span>
  The package also supports simple normalization. Currently supported are quantile normalization, log2 + quantile normalization, and cpm. In the example below we load 100 random samples and apply log quantile.

  ```python
  import archs4py as a4

  file = "human_gene_v2.4.h5"
  rand_counts = a4.data.rand(file, 100)


  norm_exp = a4.normalize(rand_counts, method="log_quantile")

  ```



  <span id="#filter-genes"></span>

  To filter genes with low expression use the `utils.filter()` function. It uses two parameters to determine which genes to filter. `readThreshold` and `sampleThreshold`. In the example below genes are removed that don't have at least 50 reads in 2% of samples. `aggregate` will also deal with duplicate gene symbols in the ARCHS4 data and aggregate the counts.

  ```python
  import archs4py as a4

  file = "human_gene_v2.4.h5"
  rand_counts = a4.data.rand(file, 100)


  filtered_exp = a4.utils.filter_genes(exp, readThreshold=50, sampleThreshold: float=0.02, deterministic: bool=True, aggregate=True)
  ```



  <span id="#aggregate-genes"></span>

  Some gene symbols are duplicated, which is an artifact from the Ensembl gene annotation. The transcript sequences are often identical and reads are split between the different entries. The `utils.aggregate_duplicate_genes()` function will sum all counts of duplicate gene symbols and eliminate duplicate entries.

  ```python
  import archs4py as a4

  file = "human_gene_v2.4.h5"
  rand_counts = a4.data.rand(file, 100)


  agg_exp = a4.utils.aggregate_duplicate_genes(rand_counts)

  ```



  <span id="#align"></span>

  The `align` module contains a replication of the ARCHS4 alignment pipeline. When used on FASTQ files the resulting gene or transcript counts are compatible with the previously aligned samples in ARCHS4. The package is highly automated and only required a path to a FASTQ file or a folder containing multiple FASTQ files. All file dependencies will downloaded automatically and index will be built when needed.



  Pass either a single or paired FASTQ file. This function can return transcript count, gene counts, or transcript level TPM data.

  ```python

  import archs4py as a4

  a4.align.load(["SRR14457464"], "data/example_1")

  result = a4.align.fastq("human", "data/example_1/SRR14457464.fastq", return_type="gene", identifier="symbol")

  ```

  The next example is a SRR file that extracts into a pair of paired end FASTQ files. They can be passed to ARCHS4py like this:

  ```python
  import archs4py as a4


  a4.align.load(["SRR15972519"], "data/example_2")

  result = a4.align.fastq("mouse", ["data/example_2/SRR15972519_1.fastq", "data/example_2/SRR15972519_2.fastq"], return_type="transcript")

  ```



  Align all FASTQ files in folder using the function `a4.align.folder()`. ARCHS4py will automatically matching samples if data is paired end.

  ```python

  import archs4py as a4

  a4.align.load(["SRR15972519", "SRR15972520", "SRR15972521"], "data/example_3")

  result = a4.align.folder("mouse", "data/example_3", return_type="gene", identifier="symbol")

  ```


  <span id="#version"></span>
  ARCHS4 has different versions to download from. Recommended is the default setting, which will download the latest data release.

  ```python
  import archs4 as a4

  print(a4.versions())

  ```



  When using ARCHS4 please cite the following reference:

  Lachmann, Alexander, Denis Torre, Alexandra B. Keenan, Kathleen M. Jagodnik, Hoyjin J. Lee, Lily Wang, Moshe C. Silverstein, and Avi Ma’ayan. "Massive mining of publicly available RNA-seq data from human and mouse." Nature communications 9, no. 1 (2018): 1366.
  https://www.nature.com/articles/s41467-018-03751-6


pkgId: be842c05f2d9d443142791c27a9bf41a6cadb386f345a7f6002b599ba4a69f99
name: python-archspec
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: A library to query system architecture
url: https://github.com/archspec/archspec
rpm_license: Apache-2.0 OR MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archspec-0.2.5-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/archspec/archspec/workflows/Unit%20tests/badge.svg)](https://github.com/archspec/archspec/actions)
  [![CodeCov](https://codecov.io/gh/archspec/archspec/branch/master/graph/badge.svg)](https://codecov.io/gh/archspec/archspec)
  [![Documentation Status](https://readthedocs.org/projects/archspec/badge/?version=latest)](https://archspec.readthedocs.io/en/latest/?badge=latest)

  Archspec aims at providing a standard set of human-understandable labels for
  various aspects of a system architecture  like CPU, network fabrics, etc. and
  APIs to detect, query and compare them.

  This project grew out of [Spack](https://spack.io/) and is currently under
  active development. At present it supports APIs to detect and model
  compatibility relationships among different CPU microarchitectures.



  The `archspec` Python package needs [poetry](https://python-poetry.org/) to
  be installed from VCS sources. The preferred method to install it is via
  its custom installer outside of any virtual environment:

  ```console
  curl -sSL https://install.python-poetry.org | python3 -
  ```

  You can refer to [Poetry's documentation](https://python-poetry.org/docs/#installation)
  for further details or for other methods to install this tool. You'll also need `tox`
  to run unit test:

  ```console
  pip install --user tox
  ```

  Finally, you'll need to clone the repository:

  ```console
  git clone --recursive https://github.com/archspec/archspec.git
  ```



  Once you have your environment ready you can run `archspec` unit tests
  using ``tox`` from the root of the repository:

  ```console
  $ tox
    [ ... ]
    py27: commands succeeded
    py35: commands succeeded
    py36: commands succeeded
    py37: commands succeeded
    py38: commands succeeded
    pylint: commands succeeded
    flake8: commands succeeded
    black: commands succeeded
    congratulations :)
  ```



  If you are referencing `archspec` in a publication, please cite the following
  paper:

  * Massimiliano Culpo, Gregory Becker, Carlos Eduardo Arango Gutierrez, Kenneth
     Hoste, and Todd Gamblin.
     [**`archspec`: A library for detecting, labeling, and reasoning about
     microarchitectures**](https://tgamblin.github.io/pubs/archspec-canopie-hpc-2020.pdf).
     In *2nd International Workshop on Containers and New Orchestration Paradigms
     for Isolated Environments in HPC (CANOPIE-HPC'20)*, Online Event, November
     12, 2020.



  Archspec is distributed under the terms of both the MIT license and the
  Apache License (Version 2.0). Users may choose either license, at their
  option.

  All new contributions must be made under both the MIT and Apache-2.0
  licenses.

  See [LICENSE-MIT](https://github.com/archspec/archspec/blob/master/LICENSE-MIT),
  [LICENSE-APACHE](https://github.com/archspec/archspec/blob/master/LICENSE-APACHE),
  [COPYRIGHT](https://github.com/archspec/archspec/blob/master/COPYRIGHT), and
  [NOTICE](https://github.com/archspec/archspec/blob/master/NOTICE) for details.

  SPDX-License-Identifier: (Apache-2.0 OR MIT)

  LLNL-CODE-811653


pkgId: 2330bb61058a2821b6a1ed88a9118374c15b1ab7d0854db661b0d5882b37c7df
name: python-archytas
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: A library for pairing LLM agents with tools so they perform open ended tasks
url: https://pypi.org/project/archytas/
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-archytas-1.2.3-1.src.rpm
checksum_type: sha256
description:
  <img src="assets/logo.png" width="150" height="150" align="left" style="padding-right:0.5em;"/>

  Implementation of the [ReAct (Reason & Action)](https://arxiv.org/abs/2210.03629) framework for Large Language Model (LLM) agents. Mainly targeting OpenAI's GPT-4.

  Easily create tools from simple python functions or classes with the `@tool` decorator. A tools list can then be passed to the `ReActAgent` which will automagically generate a prompt for the LLM containing usage instructions for each tool, as well as manage the ReAct decision loop while the LLM performs its task.

  Tools can be anything from internet searches to custom interpreters for your domain. Archytas provides a few built-in demo tools e.g. datetime, fibonacci numbers, and a simple calculator.

  <div style="clear:left;"></div>


  Short demo of using the `PythonTool` to download a COVID-19 dataset, and perform some basic processing/visualization/analysis/etc.
  <div align="center">
    <a href="https://youtu.be/52e4xN8SIi8">
      <img src="assets/covid_repl_demo.gif" alt="Watch the video">
    </a>
    <br/>
    click to watch original video on youtube
  </div>


  ```bash

  pip install poetry


  git clone git@github.com:jataware/archytas.git
  cd archytas
  poetry install



  export OPENAI_API_KEY="sk-..."


  poetry run chat-repl
  ```


  Import pre-made tools from the tools module
  ```python
  from archytas.react import ReActAgent, FailedTaskError
  from archytas.tools import PythonTool

  from easyrepl import REPL


  some_tools = [PythonTool, ..., etc.]
  agent = ReActAgent(tools=some_tools, verbose=True)


  for query in REPL():
      try:
          answer = agent.react(query)
          print(answer)
      except FailedTaskError as e:
          print(f"Error: {e}")
  ```


  See the [wiki docs](https://github.com/jataware/archytas/wiki) for details.


pkgId: 834d384f170882d14fde3bf831c5cf7f40d204f92166e128558d7cbb721fe1a9
name: python-arcle
arch: src
version: 0.2.6
epoch: 0
release: 1
summary: An ARC Learning Environment built on Gymnasium
url: https://github.com/ConfeitoHS/arcle
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcle-0.2.6-1.src.rpm
checksum_type: sha256
description:
  ARCLE is a lightweight Gymnasium (previously OpenAI Gym) environment for training on ARC(Abstraction and Reasoning Corpus) and ARC-like datasets.


  Python >= 3.8


  `pip install arcle`



  - Env Changes
      - **`O2ARCv2Env` is accessible via `O2ARCEnv` or `O2ARCEnv-v2`.**
      - Unify type of observations into `np.int8` (that were previously `np.uint8`)
      - Unify observation space into a dictionary of `Box` or `MultiBinary` to flatten observations properly by Gymnasium APIs
      - Remove over-conditioned (`@abstractmethod`) requirements of `AbstractARCEnv`. Now user must only override `create_operations` only.

  - **Added action wrappers** (`BBoxWrapper`, `PointWrapper`) to change `selection` to bounding box selection or one-point selection.
  - `Loader` now supports definable random number generator.
  - Orginized examples

  - Bug Fix
      - Fixed `terminated` is not emitted when `max_trial` is infinity (-1)


  - Python 3.8 Support (minimum requirements of Gymnasium)
  - Env Changes
      - **Rename `ARCEnv` into `RawARCEnv` in this version.**
      - **Removed `MiniARCEnv`. Please use `RawARCEnv` with `loader=MiniARCLoader()` instead.**
      - **New `ARCEnv` added, consisting action space of ARC testing interface given along with the ARC Dataset.**
      - States in every environments are fully observable. All state-related instance variables are now in the `current_state` dictionary.
          - All operations receives `state` and `action`, and it changes `state` in-place.
          - You can deepcopy the state and call `env.transition(state_copied, action)` to get next state without changing original state on `O2ARCv2Env`. `env.transition` will be replaced as separated utility function in the future.
      - n-trial mode added. You canset maximum trials when you call `gym.make()` by putting argument `max_trial=num`. Unlimited trial mode is available when it is set by -1 (default).
      - Customizable `Submit` operation. It is defined in each env class as a method, not in a separated module.
          - You can specify boolean option `reset_on_submit` in `env.reset` (default=`False`)

  - Bug fix
      - `FloodFill` operation without selection case fixed
      - `Paste` operation out-of-bound case fixed
      - `CopyI` operation out-of-bound case fixed
      - Apply patch exception handling


  - Bug fix
      - Default all-or-none reward now gives only when submitted. It affects to existing all environments.


  - O2ARCv2Env-v0
      - Changed `ResizeGrid` action to `CropGrid` action
      - Forced `FloodFill` action to select only one pixel (otherwise, it is NoOP)
      - Now `CopyI`, `CopyO`, `Paste` regards black pixels (pixel value 0) as a background. It copies pixels where the value is nonzero and the pixel is selected.
      - `action['selection']` can handle int (automatically casts into `np.bool_`)
  - Several exceptions handling


  - ArcEnv-v0 & MiniArcEnv-v0 has renamed to ARCEnv-v0 & MiniARCEnv-v0.
  - Changed internal `current_grid` variable to `grid` & `grid_dim`
  - **Added O2ARCv2Env-v0 environment.**
  - Added O2ARC Actions
      - Uses `selection` and `selected`. Some internal variables should be initialized.
      - Color, Flood Fill(DFS Color)
      - Move, Rotate, Flip
      - Copy, Paste and Clipboard Features (For O2ARC)


  - Change Images
  - Fix minor issues


  - Initial Build.
  - **ArcEnv-v0 & MiniArcEnv-v0 Launched.**


pkgId: db6a61e57bbd3ae3b71f849b859ffe06ca8bade36c92ea160d403cd2cf27715e
name: python-arclet-alconna
arch: src
version: 1.8.33
epoch: 0
release: 1
summary: A High-performance, Generality, Humane Command Line Arguments Parser Library.
url: https://pypi.org/project/arclet-alconna/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arclet-alconna-1.8.33-1.src.rpm
checksum_type: sha256
description:
  ![](https://socialify.git.ci/ArcletProject/Alconna/image?description=1&descriptionEditable=A%20High-performance%2C%20Generality%2C%20Humane%20Command%20Line%20Arguments%20Parser%20Library.&font=Inter&forks=1&issues=1&language=1&logo=https%3A%2F%2Farclet.top%2Fimg%2Farclet.png&name=1&owner=1&pattern=Brick%20Wall&stargazers=1&theme=Auto)
  <div align="center">



  </div>

  ![Alconna](https://img.shields.io/badge/Arclet-Alconna-2564c2.svg)
  ![latest release](https://img.shields.io/github/release/ArcletProject/Alconna)
  [![Licence](https://img.shields.io/github/license/ArcletProject/Alconna)](https://github.com/ArcletProject/Alconna/blob/master/LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/arclet-alconna)](https://pypi.org/project/arclet-alconna)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/arclet-alconna)](https://www.python.org/)
  [![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FArcletProject%2FAlconna.svg?type=shield)](https://app.fossa.com/projects/git%2Bgithub.com%2FArcletProject%2FAlconna?ref=badge_shield)

  [**简体中文**](README.md)|[**English**](README-EN.md)



  `Alconna` is a powerful cli tool for parsing message chain or other raw message data. It is an overload version of `CommandAnalysis`, affiliated to `ArcletProject`.

  `Alconna` has a large number of built-in components and complex parsing functions. ~~But do not afraid~~, you can use it as a simple command parser.



  pip
  ```shell
  $ pip install --upgrade arclet-alconna
  $ pip install --upgrade arclet-alconna[full]
  ```



  Official Document : [👉Link](https://arclet.top/docs/tutorial/alconna)

  Relevant Document : [📚Docs](https://graiax.cn/guide/message_parser/alconna.html)



  ```python
  from arclet.alconna import Alconna, Option, Subcommand, Args

  cmd = Alconna(
      "/pip",
      Subcommand("install", Option("-U|--upgrade"), Args["pak", str]),
      Option("list")
  )

  result = cmd.parse("/pip install numpy --upgrade") # This method returns an 'Arparma' class instance.
  print(result.query('install'))  # Or result.install
  ```

  Output as follows:
  ```
  value=None args={'pak': 'numpy'} options={'upgrade': value=Ellipsis args={}} subcommands={}
  ```



  QQ Group: [Link](https://jq.qq.com/?_wv=1027&k=PUPOnCSH)



  * High Performance. On i5-10210U, performance is about `71000~289000 msg/s`; test script: [benchmark](benchmark.py)
  * Intuitive way to create command components
  * Powerful Automatic Type Parse and Conversion
  * Customizable Help Text Formatter and Control of Command Analyser
  * i18n Support
  * Cache of input command for quick response of repeated command
  * Easy-to-use Construct and Usage of Command Shortcut
  * Can bind callback function to execute after command parsing
  * Can create command completion session to implement multi-round continuous completion prompt
  * Various Features (FuzzyMatch, Output Capture, etc.)

  Example of Callback Executor:

  ```python

  from arclet.alconna import Alconna, Args

  alc = Alconna("callback", Args["foo", int]["bar", str])

  @alc.bind()
  def callback(foo: int, bar: str):
      print(f"foo: {foo}")
      print(f"bar: {bar}")
      print(bar * foo)

  if __name__ == "__main__":
      alc()
  ```

  ```shell
  $ python callback.py 3 hello
  foo: 3
  bar: hello
  hellohellohello
  ```


  Example of Type Conversion:

  ```python
  from arclet.alconna import Alconna, Args
  from pathlib import Path

  read = Alconna("read", Args["data", bytes])

  @read.bind()
  def cb(data: bytes):
      print(type(data))

  read.parse(["read", b'hello'])
  read.parse("read test_fire.py")
  read.parse(["read", Path("test_fire.py")])

  '''
  <class 'bytes'>
  <class 'bytes'>
  <class 'bytes'>
  '''
  ```

  Example of Component creation:
  ```python

  from arclet.alconna import Alconna, Args, Option, Subcommand, store_true, count, append

  alc = Alconna(
      "component",
      Args["path", str],
      Option("--verbose|-v", action=count),
      Option("-f", Args["flag", str], compact=True, action=append),
      Subcommand("sub", Option("bar", action=store_true, default=False))
  )

  if __name__ == '__main__':
      res = alc()
      print(res.query("path"))
      print(res.query("verbose.value"))
      print(res.query("f.flag"))
      print(res.query("sub"))
  ```

  ```shell
  $ python component.py /home/arclet -vvvv -f1 -f2 -f3 sub bar
  /home/arclet
  4
  ['1', '2', '3']
  (value=Ellipsis args={} options={'bar': (value=True args={})} subcommands={})
  ```

  Example of Command Shortcut:
  ```python

  from arclet.alconna import Alconna, Args

  alc = Alconna("eval", Args["content", str])
  alc.shortcut("echo", {"command": "eval print(\\'{*}\\')"})

  @alc.bind()
  def cb(content: str):
      eval(content, {}, {})

  if __name__ == '__main__':
      alc()
  ```

  ```shell
  $ python shortcut.py eval print(\"hello world\")
  hello world
  $ python shortcut.py echo hello world!
  hello world!
  ```

  Example of Command Completion:
  ```python

  from arclet.alconna import Alconna, Args, Option

  alc = Alconna("complete", Args["bar", int]) + Option("foo") + Option("fool")

  if __name__ == "__main__":
      alc()
  ```

  ```shell
  $ python completion.py ?
  suggest input follows:
  * bar: int
  * --help
  * -h
  * foo
  * fool
  ```

  Example of `typing` Support:
  ```python
  from typing import Annotated  # or typing_extensions.Annotated
  from arclet.alconna import Alconna, Args

  alc = Alconna("test", Args.foo[Annotated[int, lambda x: x % 2 == 0]])
  alc.parse("test 2")
  alc.parse("test 3")

  '''
  'foo': 2
  ParamsUnmatched: param 3 is incorrect
  '''
  ```

  Example of FuzzyMatch:

  ```python

  from arclet.alconna import Alconna, CommandMeta, Arg

  alc = Alconna('!test_fuzzy', Arg("foo", str), meta=CommandMeta(fuzzy_match=True))

  if __name__ == "__main__":
      alc()

  ```

  ```shell
  $ python fuzzy.py /test_fuzzy foo bar
  /test_fuzy not matched. Are you mean "!test_fuzzy"?
  ```



  | Name           | File                                     |
  |----------------|------------------------------------------|
  | Calculate      | [calculate.py](./example/calculate.py)   |
  | Execute        | [exec_code.py](./example/exec_code.py)   |
  | Request Route  | [endpoint.py](./example/endpoint.py)     |
  | Image Search   | [img_search.py](./example/img_search.py) |
  | PIP            | [pip.py](./example/pip.py)               |
  | Database Query | [exec_sql.py](./example/exec_sql.py)     |



  Alconna is licensed under the [MIT License](LICENSE).

  [![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FArcletProject%2FAlconna.svg?type=large)](https://app.fossa.com/projects/git%2Bgithub.com%2FArcletProject%2FAlconna?ref=badge_large)



  [JetBrains](https://www.jetbrains.com/): Support Authorize for [PyCharm](https://www.jetbrains.com/pycharm/)<br>
  [<img src="https://cdn.jsdelivr.net/gh/Kyomotoi/CDN@master/noting/jetbrains-variant-3.png" width="200"/>](https://www.jetbrains.com/)


pkgId: c745cc598b1f4b57337c1f2253fb1292986c6e0bce5a326324594fa9473faaaa
name: python-arcor2
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: ARCOR2 base library
url: https://pypi.org/project/arcor2/
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcor2-1.5.0-1.src.rpm
checksum_type: sha256
description:
  The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),





  - Added a new universal dataclass `InverseKinematicsRequest` for IK requests (simplifies HTTP requests).






  - Optional `thread_id` added to `ActionStateBefore` - the value is supposed to be set for any action running on a thread other than main.





  - Updated dependencies, switched to Python 3.11.





  - `save_type_def` helper function.





  - Few new helper functions.



  - Object pose is now not set using a property setter but using the `set_pose` method.





  - Updated dependencies.
  - Compatibility with the Project service 1.0.0.
    - `Mesh` dataclass: `data_id` changed to `asset_id`.
    - Updated client (some paths were changed).



  - Method `start` from the Scene service client now allows to specify a timeout.





  - Optional property `end_effector_id` added to `ProjectRobotJoints`.





  - Switched to Python 3.10, updated dependencies.
  - Removed unused `children` property from `SceneObject`.
  - Removed unused assets-related functions from Project service client.





  - REST client updated, so it is possible to specify a filename when, e.g., uploading a file to the Project service.





  - Target REST endpoints for `arcor2.clients.scene_service` updated to match new API convention.
    - `/collisions/{model_type}/{model_id}` changed to `/collisions/{model_type}`, `model_id` moved to request
    parameters as `{model_type}Id`.
    - `/transforms/{transform_id}/local-pose` changed to `/transforms/{transform_id}/pose/local`.
    - `/transforms/{transform_id}/world-pose` changed to `/transforms/{transform_id}/pose/world`.






  - **BREAKING**: `data.common.WebApiError` is now JSON based exception.
    - Property `errors` was removed.
    - New properties `type`, `description` and optional `content`.

  - **BREAKING**: `flask.FlaskException` class updated.
    - `FlaskException` does no longer accept message and error code, but only `message` and optional `context`.
    - New `service` and `description` properties should be overridden by subclasses.
    - Exception instances are now convertible to JSON.

  - **BREAKING**: Flask API error handlers return 500 error code for any error.
     `WebApiError` JSON object is supplied in response body.

  - **BREAKING** : `rest.WebApiException`, `rest.RestHttpException` class gone. `WebApiError` and
   `RestException` are raised instead. No HTTP code is supplied as the only possible error code is 500.

  - **BREAKING** : `scene_service` client changed.
    - `world_pose` now call `.../world-pose` instead of `.../worldPose`.
    - `local_pose` now call `.../local-pose` instead of `.../localPose`.
    - `line_check` now call `.../line-safe` instead of `.../lineSafe`.
    - `upsert_collision` model id moved from query parameters to path.



  - New `WebApiErrorFactory` class was implemented to generate service specific
    `WebApiError` schemas for swagger documentation.

  - `flask.run_app` now accept optional `dependencies` argument.





  - Simple collision checking.
    - Related dataclasses were added.
    - New function in `scene_service` client.





  - **BREAKING**: `ActionStateBefore` event updated.
    - Properties `action_id` and `parameters` are now optional.
    - New optional property `action_point_ids`.
  - Switched to Python 3.9, updated dependencies.





  - New abstract base class `VirtualCollisionObject`.
    - Meant as a base for 'dumb' collision objects, with primitive models, without any functionality, e.g. for safety 'walls' around the cell.
  - `ActionMetadata` updated.
    - Removed useless properties (`blocking`, `blackbox`).
    - Added a new property `hidden` (UIs shall silently ignore those actions).
  - Dropped support for `RelativePose` action parameter type.
  - Handle all errors when importing stuff (`import_type_def`).
    - This is needed for instance in case of obsolete ObjectTypes.
    - ...when e.g. parameters of `ActionMetadata` were changed.
    - Otherwise outdated OT might raise `TypeError` or similar exceptions.
  - New (optional) properties added to `BareActionPoint` (compatibility with Project service 0.14.0 or newer).
  - Added `FlowActions` ObjectType, providing `is_first_pass` action which is useful to perform the initialization step.



  - Action point transformations (reparenting).
    - When AP1 from `object -> AP1 -> AP2` was made global, AP2 was not updated properly.
    - When AP1 was made relative again, AP2 was again not updated.





  - Added `Robot` specific exception `KinematicsException`.
    - So far used to give more precise error messages.
  - `ProjectParameter` now derives from `Parameter`.
  - `CachedScene` now caches ObjectTypes used in a scene.
  - Logs are now colored.
  - `Project` now has optional `project_objects_ids` property (not used at the moment).



  - Make sure that `Pose` contain only floats.
    - When any value is e.g. np.float64, `orjson` complains.
    - Because of this, `to_dict` methods of `Position` and `Orientation` are overridden.
  - Typo in URL within `get_models` of `project_service` client.
  - Missing sleep in `wait_for` of `scene_service` client.





  - Object hierarchy modified.
    - `GenericWithPose` now can't have a collision model.
    - A new `CollisionObject` must have collision model.
  - `Robot` base class API changed.
    - Parameter `linear` was added to `move_to_pose`.
      - A robot not supporting linear movements should raise exception when `linear==True`.
    - Parameter `include_gripper` was added to `robot_joints`.
      - By default, the method should return only arm's joints.
      - With the parameter set, the list should contain also gripper joints.
      - This is needed for visualization of grippers.
      - Makes only sense (so far) when gripper is part of URDF.
  - Scene/Project clients now log underlying error messages.



  - `rest` module now encodes body data as utf-8.






  - Support for multi arm robots.
    - New base class `MultiArmRobot`.
    - Its methods have an additional `arm_id` parameter.
    - There is a method to get arm IDs.
    - Relevant ARServer RPCs were extended with `arm_id`.
    - `ProjectRobotJoints` model now also contains `arm_id`.
    - There is `DummyMultiArmRobot` ObjectType for testing purposes.
  - `CachedProject`: `constants` renamed to `parameters`.
  - `Generic`: `INIT_PRIORITY` removed as useless.
  - `GenericWithPose`: do not delete collision models in `cleanup`.
    - Collision models are removed by the Scene service on `stop`.
  - Usage of `orjson` in `arcor2/json` and for dataclasses.
    - 40% speedup for serialization.
    - 80% speedup for deserialization.
    - Tested on `Project` dataclass.
  - Compatibility with Project service 0.10.0.
  - Compatibility with Scene service 0.5.0.
  - Uploading of meshes associated to ObjectTypes.
    - Parameter `file_to_upload` was added to `upload_def`.



  - Correct default port for Project service (10000).




  - Modules `package` and `resources` moved to `arcor2_execution_data`.




  - Project service client updated to API version 0.8.0.
  - `ARCOR2_PERSISTENT_STORAGE_URL` renamed to `ARCOR2_PROJECT_SERVICE_URL`.
  - Dependencies updated.




  - Objects initialization order (`Resources`):
    - Object initialization order can be set using class-level `INIT_PRIORITY` variable.
    - The higher priority, the sooner are objects of that type initialized.
    - Objects are initialized serially.
  - `CachedProject` has new methods to deal with hierarchy (`get_by_id`, `get_parent_id`, `childs`).
  - Project service client updated to be compatible with version 0.7.0.
  - Added a custom `json` module.
    - Wraps the standard json module, so it might be easier to replace it in the future.
    - Provides type annotations.
    - Raises a custom exception based on `Arcor2Exception`.


  - Handling of context manager arguments in `Resources`.




  - REST client now handles all codes >= 400 as errors.




  - Save and import of ObjectType was randomly failing because of [race condition](https://docs.python.org/3.8/library/importlib.html#importlib.machinery.FileFinder).




  - Improved code for transforming poses.
  - Use monkey patching instead of custom released version of dataclasses_jsonschema.
  - Switched to builtin ast module instead of horast - much faster builds, etc.
  - Added states `Stopping` and `Pausing` to `PackageState.Data.StateEnum`.
    - This is because it may take some time to pause or stop a package.
    - Other operations (as e.g. resume) are almost instant.


  - `Resources` are now not sending `KeyboardInterrupt` as event.
  - `import_type_def` now provides better error messages when import fails.
  - Save and import of ObjectType was randomly failing.




  - IDs (uuid) are now generated within the respective classes.
    - If necessary, ID can be still provided from outside as before.
    - IDs are prefixed so developers can easily check type of an object from its ID.
    - Prefix always start with a character.


  - Composite actions are now properly handled by the `@action` decorator.




  - `Pose` parameter plugin fixed to generate correct code in a case when action on action point A uses orientation from action point B.




  - Parameter plugins now return copy of the parameter in order to prevent changes in the project if the value is modified e.g. within an action.
  - Method `update_project_sources` of the Project service client was fixed.


  - Flask-based apps now don't log each API call by default.
    - It can be turned on by setting `ARCOR2_REST_API_DEBUG`.
  - The `rest` module has a new exception type RestHttpException for getting HTTP error codes.
  - `is_valid_identifier` now behaves the same as `is_valid_type`, it does not insist on convention (PascalCase vs snake_case) and provides concrete error messages.
  - `Robot` API now has `safe` parameter.
  - `Robot` now has API for hand teaching mode.
  - Line length of generated code changed from 80 to 120.




  - `@action` decorator fixed.
  - `KeyError` was raised when `an` parameter was not given to an action.
  - This only happened in the "manual" script writing scenario and when `patch_object_actions` was used.




  - Explicit action parameters.
    - `Resources` class now do not need to deal with parameters.
    - Update of ObjectTypes (all actions now have the mandatory `an` parameter).
  - `CurrentAction` removed, `ActionState` divided into `ActionStateBefore` and `ActionStateAfter`.
  - New module with shared code for Flask-based apps.
  - Updates of 3rd party dependencies.
  - WS server now logs too long RPCs.
    - Max. duration could be configured using `ARCOR2_MAX_RPC_DURATION`.


  - At a startup, the main script now checks if the scene is running before attempt to stop it.
  - `image_from_str` function fixed.




  - `action` decorator now handles outputs of actions.
  - `CachedProject` has new methods for handling project logic.
  - `ActionState` event now contains action results.
  - New built-in ObjectTypes `RandomActions`.
  - Parameter plugins slightly reworked, some new helper functions.
  - If a robot has URDF, it is zipped and uploaded to the Project service).
    - ...as a mesh file, which is workaround for missing storage of URDF models.
  - Scene service client updated to support version 0.4.0.
  - New built-in abstract ObjectType `Camera`.
  - Initial support for loading of URDF files.
  - Some first tests for parameter plugins were added.




  - `parse` function now also catches `ValueError` exception.
  -  `check_object_type` now tries to parse whole module instead of just source of the class itself.


  - `Robot` base class now have methods for IK/FK.
  - It is possible to use `==` on `Position` instances.




  - package_version was ignoring `package` argument




  - Scene client updated for Scene 0.3.0.
  - Exceptions refactored (BREAKING).
    - Arcor2Exception no longer has `message` property
    - There is a new package arcor2/exceptions.
    - Clients using `handle` decorator now have specific error messages defined.
    - Previously generated execution packages will become broken as `print_exception` function was moved
  - Loggers are now created using functions from `logging` module.
  - `rest` module rewritten (BREAKING).
    - Now there is only one method `call` which takes http method as an argument.
    - There is `ARCOR2_REST_DEBUG` environment variable. When set, debugging logs are turned on.


  - JSON containing only boolean value was not handled properly by `arcor2.rest` module.




  - Reorganisation of the repository - switched to monorepo based on [Pants](https://www.pantsbuild.org/docs/welcome-to-pants). The code was divided into more packages (that can be separatelly relased) within one repository.
  - Tests now run on GitHub instead of CircleCi.
  - Unification of objects and services
    - There is ```Generic``` base class for objects without pose, ```GenericWithPose``` for objects with pose and ```Robot``` class that should be base class for every robot.
  - Integration of scene service (0.2.0).
  - @action decorator is now added automatically in the run-time.
  - ```Orientation``` dataclass now performs quaternion normalization in ```__post_init__```.
  - ```Robot``` base class now has ```_move_lock``` mutex to ensure that only one move-action is called at the time.







  - Some robot-related issues fixed



  - Scene service client: 'upsert_collision' now has optional 'mesh_parameters': parameter.



  - New logic representation
  - Unification of objects and services
  - Integration of scene service



  - Fix of broken python package arcor2 0.7.0




  - ARServer: new RPC 'TemporaryPackage'
  - ARServer: RPC ObjectTypesChangedEvent renamed to ChangedObjectTypesEvent, now contains changed ObjectTypes meta instead of just type names
  - ARServer: ShowMainScreenEvent.
  - Package name added to PackageInfoEvent
  - ARServer now compares its API_VERSION with API_VERSION of the Execution.
  - ARServer: ShowMainScreenEvent will now not contain 'highlight' when sent to a newly connected UI.
  - AP can now have another AP as parent
  - rest: OptionalData now may contain list of primitive type.
  - Execution: PackageStateEvent now contains package_id
  - Execution: added 'executed' to PackageMeta




  - Build/Execution proxy: allow port change using env. var.
  - ARServer: RenameScene RPC now checks if scene name is unique and 'dry_run' works.
  - ARServer: ListScenes/ListProjects now contain 'modified'.
  - ARServer: DeleteObjectType RPC added.
  - @action decorator is now compatible with Windows.
  - Service class now has 'cleanup' method which is called when scene is closed or when script ends. Call of 'cleanup' can be disabled by 'export ARCOR_CLEANUP_SERVICES=False' - this is particularly useful when running the script manually again and again.
  - Cleanup method for ObjectTypes.



  - ignoring check of return parameters
  - allowing list of strings as request body



  - ARServer container need to setup new env variable using docker-compose -> ARCOR2_DATA_PATH=/root/data
  - ListProjects RPC now gets projects in parallel.
  - dry_run parameter for selected RPCs
  - EEF pose/robot joints streaming
  - OpenScene, OpenProject, SceneClosed, ProjectClosed events.
  - Execution proxy: use persistent websocket connection.
  - SceneCollisionsEvent merged into PackageInfoEvent
  - ARServer: RPC to cancel action execution.
  - Execution package now contains package.json with its metadata. Execution service now supports renaming of packages.



  - added support for CORS



  - Fix of functions to transform relative poses to absolute and vice versa



  - New RPCs for getting robot joints and effector pose
  - New RPC to get IDs of EE and suctions
  - Added pivot enum for UpdateObjectPoseUsingRobot


  - Fix of remove action RPC
  - Another fixes




  - Complete redesign of RPC for ARClients (AREditor atm)
  - Documentation of execution and build API
  - Support for project service 0.2.0
  - New and updated events
  - Enhanced error messages
  - Create (global) session to enable reuse of connections.



  - Renamed RobotJoints to ProjectRobotJoints and ModelTypeEnum to Model3dType
  - Added new services for Time and Logic related actons
  - Added boolean parameter plugin
  - Description, returns and origins fields marked as optional
  - New event - ActionResult
  - Separated script enabling discovery through UDP broadcast
  - Support for list params
  - Services and Action objects are now marked as disabled when some problem occured and error message is passed to GUI (previously such services/objects were ignored)
  - Services with no configuration are disabled



  - Added compatibility with Project service v 0.1.1
  - Param values and defaults are strings now
  - min, max stored in extra as JSON string



  - ExecuteAction RPC.
  - Uuid for action object/point/action.
  - Execution proxy PUT method
  - ActionPoint class in execution package
  - Removed loop in main script, when hasLogic == false
  - Parameter values not send in currentAction event
  - ProjectState RESUMED removed
  - Execution: print out script output if not JSON.
  - Joint: rotation -> value




  - Build: disable caching



  - Parameter plugins



  - Parameter of type relative_pose now accepts json string as value



  - N/A



  - bump docker version



  - bump docker version



  - N/A



  - Separation of services.


