# packages

pkgId: 3c037f6ef7ce3afa436e3ba3d9fb787d9a44556116ef32a4a25e07c695006e91
name: python-cloudvision
arch: src
version: 1.21.1
epoch: 0
release: 1
summary: A Python library for Arista's CloudVision APIs and Provisioning Action integrations.
url: https://pypi.org/project/cloudvision/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cloudvision-1.21.1-1.src.rpm
checksum_type: sha256
description:
  The Arista CloudVision Python library provides access to Arista's CloudVision
  APIs for use in Python applications.



  API Documentation for this library can be found [here](https://aristanetworks.github.io/cloudvision-python/).

  Documentation for CloudVision's Resource APIs can be found [here](https://aristanetworks.github.io/cloudvision-apis).

  Documentation for generic access to CloudVision can be found at [CloudVision Connector](#cloudvision-connector).



  Install via pip:

  ```sh
  pip install --upgrade cloudvision
  ```

  Or from source:

  ```sh
  python setup.py install
  ```



  - CloudVision Resource APIs: Python 3.7+
  - CloudVision Connector: Python 3.7+
  - Examples: Python 3.7+



  Cloudvision APIs are state based, resource-oriented APIs modeled in [Protobuf](https://developers.google.com/protocol-buffers) and accessed over [gRPC](https://grpc.io/) using a standardized set of RPC verbs.

  CloudVision is a powerful platform that processes and stores tremendous amounts of network data. It knows the topology of the network, device configuration, interface activity and other network events. These APIs allow access to fleet-wide data access and control, forming a management-plane with consistent usage.

  For example, consider the following script that gets all existing and then watches for new CloudVision events of critical severity and notifies an administrator when raised and notes it on the event:

  ```python
  import time
  import google.protobuf.wrappers_pb2
  import grpc
  from arista.event.v1 import models, services



  with grpc.secure_channel("www.arista.io:443", channelCredentials) as channel:
      event_stub = services.EventServiceStub(channel)
      event_annotation_stub = services.EventAnnotationConfigServiceStub(channel)

      event_watch_request = services.EventStreamRequest(
          partial_eq_filter=[models.Event(severity=models.EVENT_SEVERITY_CRITICAL)],
      )
      for resp in event_stub.Subscribe(event_watch_request):
          print(f"Critical event {resp.title.value} raised at {resp.key.timestamp}")
          

          
          now_ms = int(time.time() * 1000)
          notes_to_set = {
              now_ms: models.EventNoteConfig(
                  note=google.protobuf.wrappers_pb2.StringValue(
                      value="Administrator alerted",
                  ),
              ),
          }
          annotation_config = models.EventAnnotationConfig(
              key=resp.key,
              notes=models.EventNotesConfig(
                  notes=notes_to_set,
              ),
          )
          event_note_update = services.EventAnnotationConfigSetRequest(value=annotation_config)
          event_annotation_stub.Set(event_note_update)
  ```



  CloudVision Connector is a Python implementation of a GRPC client for CloudVision. It takes care
  of getting and publishing data and datasets, and also provides utilities for data
  representation.



  This is a small example advertising a few of the GRPC client capabilities.
  This example prints info from all devices streaming into CloudVision.

  ```python
  targetDataset = "analytics"
  path = ["DatasetInfo", "Devices"]

  keys = []
  ProtoBufQuery = CreateQuery([(path, keys)], targetDataset)
  with GRPCClient("my-cv-host:9900") as client:
       for notifBatch in client.Get([query]):
           for notif in notifBatch["notifications"]:
               
               PrettyPrint(notif["updates"])
  ```


pkgId: 3180e249b66b963f579c8bc18f934cbdff5a9c752d160ec29eb1deeccb67b71b
name: python-cloudwanderer
arch: src
version: 0.29.2
epoch: 0
release: 1
summary: A Python package which wanders across your AWS account and records resources in multiple databases
url: https://github.com/CloudWanderer-io/CloudWanderer
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cloudwanderer-0.29.2-1.src.rpm
checksum_type: sha256
description:
  .. image :: https://user-images.githubusercontent.com/803607/101322139-7111b800-385e-11eb-9277-c6bf3a580987.png

  |version| |checks| |docs|

  .. |version|
     image:: https://img.shields.io/pypi/v/cloudwanderer?style=flat-square
        :alt: PyPI
        :target: https://pypi.org/project/cloudwanderer/

  .. |checks|
     image:: https://img.shields.io/github/workflow/status/cloudwanderer-io/cloudwanderer/Python%20package/main?style=flat-square
        :alt: GitHub Workflow Status (branch)
        :target: https://github.com/CloudWanderer-io/CloudWanderer/actions?query=branch%3Amain

  .. |docs|
     image:: https://readthedocs.org/projects/cloudwanderer/badge/?version=latest&style=flat-square
        :target: https://www.cloudwanderer.io/en/latest/?badge=latest
        :alt: Documentation Status

  | **Documentation:** `CloudWanderer.io <https://www.cloudwanderer.io>`_
  | **GitHub:** `https://github.com/CloudWanderer-io/CloudWanderer <https://github.com/CloudWanderer-io/CloudWanderer>`_

  A Python package which allows you to enumerate and store your AWS Resources in AWS Neptune (or Gremlin for local execution) in order to be able to ask questions like:

  1. `What EC2 instances do I have that are in Public Subnets that have roles and are accessible from the internet? <https://www.youtube.com/watch?v=GARTSsyYkk8>`__
  2. How old are my IAM users access keys?
  3. What lambda functions do I have that are connected to VPCs that have access to the internet via a NAT gateway?
  4. How many untagged VPCs do I have across all regions?

  .. image:: https://www.cloudwanderer.io/en/latest/_images/cloudwanderer_graph.png
     :alt: AWS resources represented on a graph

  What does it do?
  """"""""""""""""""

  .. image:: images/discovering-ec2-instances-video.png
     :target: https://www.youtube.com/watch?v=GARTSsyYkk8
     :alt: YouTube video demonstrating how to query public ec2 instances with CloudWander and OpenCypher.

  What the above `YouTube video <https://www.youtube.com/watch?v=GARTSsyYkk8>`__ to see an example of what you can do with CloudWanderer.


  Installation
  """""""""""""""

  .. code-block ::

     pip install cloudwanderer

  Local Quickstart
  """"""""""""""""""

  Spin up a local `Gremlin Graph Database server <http://tinkerpop.apache.org/docs/current/reference/#gremlin-server>`__ and a Jupyter Notebook.

  .. code-block ::

     $ git clone https://github.com/CloudWanderer-io/docker-graph-notebook.git
     $ cd docker-graph-notebook
     $ docker-compose up

  Look in the output for something that looks like:

  .. code-block::

     jupyter-notebook_1  |     Or copy and paste one of these URLs:
     jupyter-notebook_1  |         http://localhost:8888/?token=88dc054886e3ea73480de91066937a33c9bc8bd484eb395c

  Open the URL in question in a tab in your browser.


  Open up Python **in your preferred IDE** and import and initialise `CloudWanderer`

  .. code-block ::

     >>> import logging
     >>> from cloudwanderer import CloudWanderer
     >>> from cloudwanderer.storage_connectors import GremlinStorageConnector
     >>> storage_connector = GremlinStorageConnector(
     ...     endpoint_url="ws://localhost:8182"
     ... )
     >>> wanderer = CloudWanderer(storage_connectors=[storage_connector])
     >>> logging.basicConfig(level='INFO')

  Get all the resources from your AWS account and save them to your local Gremlin graph database.

  .. code-block ::

     >>> wanderer.write_resources()

  Go to the Jupyter Notebook link you opened earlier and, **create a new notebook by hitting 'new'** on the top right, and type the following into a new cell to get a list of VPCs.

  .. code-block::

     %gremlin
     g.V().hasLabel('aws_ec2_vpc').out().path().by(valueMap(true))

  Voila!

  .. image:: https://user-images.githubusercontent.com/803607/144116568-ef8e6d38-11f6-477e-8c30-0882fbe29c94.png
     :alt: Example Query and graph output

  You can learn more Gremlin (the language that's supported by the local setup here) by reading `Kevin Lawrence's amazing book on Gremlin <https://kelvinlawrence.net/book/Gremlin-Graph-Guide.html>`__
  OR you can get stuck in to the much more straightforward OpenCypher language by following the `Neptune Quickstart guide <https://www.cloudwanderer.io/en/latest/neptune_quickstart.html>`__.


pkgId: f2bd396566bf8673a650ecd4aaa47a2f21b4181ed90a3e3c2365d0fc06eb4a93
name: python-cloudwatch-fluent-metrics
arch: src
version: 0.5.3
epoch: 0
release: 1
summary: AWS CloudWatch Fluent Metrics
url: https://github.com/awslabs/cloudwatch-fluent-metrics
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cloudwatch-fluent-metrics-0.5.3-1.src.rpm
checksum_type: sha256
description:
  `FluentMetrics` is an easy-to-use Python module that makes logging CloudWatch custom metrics a breeze. The goal is to provide a framework for logging detailed metrics with a minimal footprint. When you look at your code logic, you want to see your actual code logic, not line after line of metrics logging.  `FluentMetrics` lets you maximize your metrics footprint while minimizing your metrics code footprint.

  You can install directly from PyPI:

  ```sh
  pip install cloudwatch-fluent-metrics
  ```

  Fluent describes an easy-to-read programming style. The goal of fluent development is to make code easier to read and reduce the amount of code required to build objects. It's easier to take a look a comparison between fluent and non-fluent style.

  ```sh
  g = Game()
  f = Frame(Name='Tom')
  f.add_score(7)
  f.add_score(3)
  g.add_frame(f)
  f = Frame(Name='Tom')
  f.add_strike()
  g.add_frame(f)
  ```

  ```sh
  g = Game()
  g.add_frame(Frame(Name='Tom', Score1=7, Score2=3)
  g.add_frame(Frame(Name='Tom', Score1=10)
  ```

  ```sh
  g = Game()
  g.add_frame(Frame().with_name('Tom').score(3).spare())
  g.add_frame(Frame().with_name('Tom').strike())
  ```
  While the difference may seem to be nitpicking, a frame is really just a constructed object. In the first example, we're taking up three lines of code to create the object--there's nothing wrong with that. However, in the second example, we're using constructors. This is slightly more readable, but there's a great deal of logic bulked up in our constructor. In the third example, we're using fluent-style code as it starts at creating the frame and *fluently* continues until it's created the entire frame in a single line. And more importantly, *it's readable.* We're not just creating an object with a massive constructor or spending several lines of code just to create a single object.


  Every metric needs to live in a namespace. Since you are logging your own custom metrics, you need to provide a custom namespace for your metric. Click [here](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aws-namespaces.html) for a list of the standard AWS namespaces.
  *Example*:
  In this example, we're creating a simple `FluentMetric` in a namespace called `Performance`. This means that every time we log a metric with `m`, we will automatically log it to the `Performance` namespace.
  ```sh
  from fluentmetrics import FluentMetric
  m = FluentMetric().with_namespace('Performance')
  ```

  The metric name is the thing you are actually logging. Each value that you log must be tied to a metric name. When you log a custom metric with a new metric name, the name will automatically be created if it doesn't already exist. Click [here](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/viewing_metrics_with_cloudwatch.html) to see existing metrics that can help you define names for your custom metrics.
  *Example*:
  In this example, we're logging two metrics called `StartupTime` and `StuffTime` to the `Performance` namespace (we only needed to define the namespace once).
  ```sh
  m = FluentMetric().with_namespace('Performance')
  m.log(MetricName='StartupTime', Value=27, Unit='Seconds')
  do_stuff()
  m.log(MetricName='StuffTime', Value=12000, Unit='Milliseconds')
  ```

  Obviously we need to log a value with each metric. This needs to be a number since we convert this value to a `float` before sending to CloudWatch.
  **IMPORTANT**: When logging multiple values for the same custom metric within a minute, CloudWatch aggregates an average over a minute. Click [here](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/publishingMetrics.html#publishingDataPoints) for more details.

  The PutMetricData function now accepts an optional StorageResolution parameter. Set this parameter to 1 to publish high-resolution metrics; omit it (or set it to 60) to publish at standard 1-minute resolution.
  *Example*:
  In this example, we're logging metric at one-second resolution:
  ```sh
  m = FluentMetric().with_namespace('Application/MyApp')
                    .with_storage_resolution(1)
  m.log(MetricName='Transactions/Sec', Value=trans_count, Unit='Count/Sec')
  ```sh

  A dimension defines how you want to slice and dice the metric. These are simply name-value pairs and you can define up to 10 per metric. Click [here](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/publishingMetrics.html#usingDimensions) for more details on using dimensions.
  **IMPORTANT:** When you define multiple dimensions, CloudMetrics attaches all of those dimensions to the metric as a single combined dimension set--think of them as an aggregate primary key. For example, if you log a metric with the dimensions `os = 'linux'` and `flavor='ubunutu'` you will only be able to aggregate by **both** `os` and `flavor`. You **cannot** aggregate only by just `os` or just `flavor`. `FluentMetrics` solves this problem by automatically logging three metrics--one for `os`, one for `flavor` and then one for the combied dimensions, giving you maximum flexibility.
  *Example*:
  In this example, we're logging boot/restart time metrics. When this code executes, we will end up with 6 metrics:
  * `BootTime` and `RestartTime` for `os`
  * `BootTime` and `RestartTime` for `instance-id`
  * `BootTime` and `RestartTime` for 'os` and `instance-id`
  ```sh
  m = FluentMetric().with_namespace('Performance/EC2') \
                    .with_dimension('os', 'linux'). \
                    .with_dimension('instance-id', 'i-123456')
  boot_time = start_instance()
  m.log(MetricName='BootTime', Value=boot_time, Unit='Milliseconds')
  restart_time = restart_instance()
  m.log(MetricName='RestartTime', Value=restart_time, Unit='Milliseconds')
  ```

  CloudWatch has built-in logic to provide meaning to the metric values. We're not just logging a value--we're logging a value of some unit. By defining the unit type, CloudWatch will know how to properly present, aggregate and compare that value with other values. For example, if you submit a value with unit `Milliseconds`, then it can properly aggregate it up to seconds, minutes or hours. This is a list of the most current valid list of units. A more up-to-date list should be available [here](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_MetricDatum.html) under the **Unit** section,.
  ```sh
  "Seconds"|"Microseconds"|"Milliseconds"|"Bytes"|"Kilobytes"|"Megabytes"|
  "Gigabytes"|"Terabytes"|"Bits"|"Kilobits"|"Megabits"|"Gigabits"|"Terabits"|
  "Percent"|"Count"|"Bytes/Second"|"Kilobytes/Second"|"Megabytes/Second"|
  "Gigabytes/Second"|"Terabytes/Second"|"Bits/Second"|"Kilobits/Second"|
  "Megabits/Second"|"Gigabits/Second"|"Terabits/Second"|"Count/Second"|"None"
  ```

  If you don't want to type out the individual unit name, there are shortcut methods for each unit.

  ```sh
  m = FluentMetric().with_namespace('Performance/EC2') \
                    .with_dimension('os', 'linux'). \
                    .with_dimension('instance-id', 'i-123456')
  m.seconds(MetricName='CompletionInSeconds', Value='1000')
  m.microseconds(MetricName='CompletionInMicroseconds', Value='1000')
  m.milliseconds(MetricName='CompletionInMilliseconds', Value='1000')
  m.bytes(MetricName='SizeInBytes', Value='1000')
  m.kb(MetricName='SizeInKb', Value='1000')
  m.mb(MetricName='SizeInMb', Value='1000')
  m.gb(MetricName='SizeInGb', Value='1000')
  m.tb(MetricName='SizeInTb', Value='1000')
  m.bits(MetricName='SizeInBits', Value='1000')
  m.kbits(MetricName='SizeInKilobits', Value='1000')
  m.mbits(MetricName='SizeInMegabits', Value='1000')
  m.gbits(MetricName='SizeInGigabits', Value='1000')
  m.tbits(MetricName='SizeInTerabits', Value='1000')
  m.pct(MetricName='Percent', Value='20')
  m.count(MetricName='ItemCount', Value='20')
  m.bsec(MetricName='BandwidthBytesPerSecond', Value='1000')
  m.kbsec(MetricName='BandwidthKilobytesPerSecond', Value='1000')
  m.mbsec(MetricName='BandwidthMegabytesPerSecond', Value='1000')
  m.gbsec(MetricName='BandwidthGigabytesPerSecond', Value='1000')
  m.tbsec(MetricName='BandwidthTerabytesPerSecond', Value='1000')
  m.bitsec(MetricName='BandwidthBitsPerSecond', Value='1000')
  m.kbitsec(MetricName='BandwidthKilobitsPerSecond', Value='1000')
  m.mbitsec(MetricName='BandwidthMegabitsPerSecond', Value='1000')
  m.gbitsec(MetricName='BandwidthGigabitsPerSecond', Value='1000')
  m.tbitsec(MetricName='BandwidthTerabitsPerSecond', Value='1000')
  m.countsec(MetricName='ItemCountsPerSecond', Value='1000')
  ```

  One of the most common uses of logging is measuring performance. FluentMetrics allows you to activate multiple built-in timers by name and log the elapsed time in a single line of code. **NOTE:** The elapsed time value is automatically stored as unit `Milliseconds`.
  *Example*:
  In this example, we're starting timers `workflow` and `job1` at the same time. Timers start as soon as you create them and never stop running. When you call `elapsed`, `FluentMetrics` will log the number of elapsed milliseconds with the `MetricName`.
  ```sh
  m = FluentMetric()
  m.with_timer('workflow').with_timer('job1')
  do_job1()
  m.elapsed(MetricName='Job1CompletionTime', TimerName='job1')
  m.with_timer('job2')
  do_job2()
  m.elapsed(MetricName='Job2CompletionTime', TimerName='job2')
  finish_workflow()
  m.elapsed(MetricName='WorkflowCompletionTime', TimerName='workflow')
  ```

  A key feature of `FluentMetrics` is the metric stream ID. This ID will be added as a dimension and logged with every metric. The benefit of this dimension is to provide a distinct stream of metrics for an end-to-end operation. When you create a new instance of `FluentMetric`, you can either pass in your own value or `FluentMetrics` will generate a GUID. In CloudWatch, you can then see all of the metrics for a particular stream ID in chronological order. A metric stream can be a job, or a server or any way that you want to unique group a contiguous stream of metrics.
  *Example*:
  In this example, we'll have two metrics in the `Performance` namespace, each with metric stream ID of `abc-123`. We can then go to CloudWatch and filter by that stream ID to see the entire operation performance at a glance.
  ```sh
  m = FluentMetric().with_namespace('Performance').with_stream_id('abc-123')
  m.log(MetricName='StartupTime', Value=100, Unit='Seconds')
  do_work()
  m.log(MetricName='WorkCompleted', Value=1000, Unit='Milliseconds')
  ```


  This is the minimal amount of work you need to log--create a `FluentMetric` with a namespace, then log a value.
  **Result**: This code will log a single value `100` for `ActiveServerCount` in the `Stats` namespace.
  ```sh
  from fluentmetrics import FluentMetric
  m = FluentMetric().with_namespace('Stats')
  m.log(MetricName='ActiveServerCount', Value='100', Unit='Count')
  ```

  If you are logging multiple metrics to the same namespace, this is a great use case for `FluentMetrics`. You only need to create one instance of `FluentMetric` and specify a different metric name when you call `log`.
  **Result**: This code will log a single value `100` for `ActiveServerCount` in the `Stats` namespace.
  ```sh
  from fluentmetrics import FluentMetric
  m = FluentMetric().with_namespace('Stats')
  m.log(MetricName='ActiveServerCount', Value='10', Unit='Count') \
   .log(MetricName='StoppedServerCount', Value='20', Unit='Count') \
   .log(MetricName='ActiveLinuxCount', Value='50', Unit='Count') \
   .log(MetricName='ActiveWindowsCount', Value='50', Unit='Count')
  ````

  In the previous example, we logged a metric and identified the unit `Count`. Instead of specifying the unit, you can specify the type of object
  **Result**: This code will log a single value `100` for `ActiveServerCount` in the `Stats` namespace.

  ```sh
  from fluentmetrics import FluentMetric
  m = FluentMetric().with_namespace('Stats')
  m.count(MetricName='ActiveServerCount', Value='10')
  ```


  Normally, with FluentMetric, metrics are sent immediately when `log` is called (or `count`, `milliseconds`, etc). This
  can result in a lot of `put_metric_data` calls to CloudWatch that are not full. When you use `BufferedFluentMetric`
  instead of `FluentMetric`, it waits until it has the maximum (20) metrics before calling `put_metric_data`. This optimizes
  traffic to cloudwatch.

  In general, `BufferedFluentMetric` behaves identically to `FluentMetric`, except that now it is possible to "forget" to
  send some metrics. The `BufferedFluentMetric.flush()` method pushes out all metrics immediately (clears the buffer). It
  is often best to do this at the end of a request (or some other obviously bounded interval).

  Here is an example of how it works in Flask:

  ```python
  from flask import g
  from fluentmetrics import BufferedFluentMetric

  @app.before_request
  def start_request():
  	g.metrics = BufferedFluentMetric()
  	g.metrics.with_namespace('MyApp')
  	g.metrics.with_timer('RequestLatency')

  @app.after_request
  def end_request(response):
  	def error_counter(hundred):
  		if response.status_code / 100 == hundred:
  			return 1
  		else:
  			return 0

  	g.metrics.count(MetricName='4xxError', Value=error_counter(400))
  	g.metrics.count(MetricName='5xxError', Value=error_counter(500))
  	g.metrics.count(MetricName='Availability', Value=(1 - error_counter(500)))
  	g.metrics.elapsed(MetricName='RequestLatency', TimerName='RequestLatency')

  	
  	g.metrics.flush()
  ```



  This library is licensed under the Apache 2.0 License.


pkgId: 650ba5e541570845d9a3ff041faa5ce248766ed1daf1ac929932a92aa5ff149d
name: python-cloudwatch-logging
arch: src
version: 1.0.0
epoch: 0
release: 1
url: https://github.com/njedema/cloudwatch-logging/
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cloudwatch-logging-1.0.0-1.src.rpm
checksum_type: sha256
summary:
  A structured JSON logger that seamlessly interoperates with AWS Cloudwatch and other AWS services (e.g. Lambda)

description:
  This package provides structured JSON logging faculties designed to seamlessly interoperate with log aggregators like
  AWS Cloudwatch, ELK, and others. These faculties are provided via extension of the python's existing logging library
  and can be used as a drop in replacement.


  If you want to generate simple structured logs, use this package just like the Python logging library.

  If you want inject contextual information into your structured logs, add a LogAppender. This is great option if you want
   to run your application in somewhere like AWS Lambda, where you would want your logs to contain aws_request_id and other
    function specific metadata. See Use Case: AWS Lambda for more.

  If you want to ensure that unwanted information is removed from your logs, use a LogFilter. Filters are
  a great way to trim the size of your log lines to cut down on logging costs. Filters can also be useful in specific log
  stacks - namely the ELK stack - that need to inject specific keys like the `type` key to index logs correctly.

  Filters and Appenders can be mixed and matched through your logger's addFilter and removeFilter methods.
  Appenders and Filters are both dynamically configurable via the logger's update_appender and update_filter methods.


  ```python
  import logging
  from cloudwatch_logging import CloudwatchLogging


  logger = CloudwatchLogging.create_logger(__name__, appender=None, filter=None)
  logger.setLevel(logging.INFO)
  logger.warning("Structured logging with custom fields", extra={"custom_field": "custom_value"})
  ```


  ```python
  import logging
  from cloudwatch_logging import CloudwatchLogging


  logger = CloudwatchLogging.create_logger("your_lambda_function")
  logger.propagate = False  # disable Lambda runtime default logger from double logging lines sent to this logger
  logger.setLevel(logging.INFO)

  def your_lambda_handler(event, context):
      lamdbda_appender = CloudwatchLogging.LogAppender(context)
      logger.addFilter(lamdbda_appender)
      logger.info("This line will be logged with info from the Lambda context object!", extra={"tapped_in": True})
      logger.removeFilter(lamdbda_appender)  # ensure you do this so you don't add duplicate appenders on the same logger
  ```



  ```python
  import logging
  from cloudwatch_logging import CloudwatchLogging, Filters

  logger = CloudwatchLogging.create_logger("your_lambda_function")
  logger.setLevel(logging.INFO)


  logger.addFilter(CloudwatchLogging.LogFilter(Filters.COST_EFFECTIVE))
  logger.warning("Structured logging on the cheap!", extra={"field": "value"})
  ```



  This is a pure Python library; it can easily be installed using `pip install cloudwatch_logging`. Use the `-e` arg if you
  plan to develop locally.


  Run python3 test_cloudwatch_logging.py. Inspect the output to see what is logged. Someone should write proper tests
  but I wrote this on vacation and couldn't be bothered.


  - Check error and exception trace handling - how can we make these better?
  - Add examples for other AWS runtimes (Fargate?)


pkgId: b9bbe4e8d1fc003d3c358e47d3a78720b87e35585766892a2d675d79c22b8fad
name: python-cloudwatchmon
arch: src
version: 2.0.6
epoch: 0
release: 1
summary: Linux monitoring scripts for CloudWatch
url: https://github.com/osiegmar/cloudwatch-mon-scripts-python
rpm_license: Apache License (2.0)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cloudwatchmon-2.0.6-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/cloudwatchmon.svg)](https://badge.fury.io/py/cloudwatchmon)
  Linux monitoring scripts for CloudWatch.


pkgId: 02b83e8ef88e1e18a7b595328b74c7e3a389c91dd8056743b19212323ac66571
name: python-cloudy-with-a-chance-of-meatballs.cdk-lambda-token-authorizer-jwt
arch: src
version: 0.1.24
epoch: 0
release: 1
summary: Add a lambda function to your aws-rest-api-gateway which can be used as a token authorizer
url: https://github.com/cloudy-with-a-chance-of-meatballs/cdk-lambda-token-authorizer-jwt.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cloudy-with-a-chance-of-meatballs.cdk-lambda-token-authorizer-jwt-0.1.24-1.src.rpm
checksum_type: sha256
description:
  Add a lambda function to your project which can be used as a apigateway token authorizer

  [![View on Construct Hub](https://constructs.dev/badge?package=%40cloudy-with-a-chance-of-meatballs%2Fcdk-lambda-token-authorizer-jwt)](https://constructs.dev/packages/@cloudy-with-a-chance-of-meatballs/cdk-lambda-token-authorizer-jwt)

  [![GitHub](https://img.shields.io/github/license/cloudy-with-a-chance-of-meatballs/cdk-lambda-token-authorizer-jwt?style=flat-square)](https://github.com/cloudy-with-a-chance-of-meatballs/cdk-lambda-token-authorizer-jwt/blob/main/LICENSE)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/cloudy-with-a-chance-of-meatballs/cdk-lambda-token-authorizer-jwt?sort=semver&style=flat-square)](https://github.com/cloudy-with-a-chance-of-meatballs/cdk-lambda-token-authorizer-jwt/releases)
  [![npm (scoped)](https://img.shields.io/npm/v/@cloudy-with-a-chance-of-meatballs/cdk-lambda-token-authorizer-jwt?style=flat-square)](https://www.npmjs.com/package/@cloudy-with-a-chance-of-meatballs/cdk-lambda-token-authorizer-jwt)
  [![PyPI](https://img.shields.io/pypi/v/cloudy-with-a-chance-of-meatballs.cdk-lambda-token-authorizer-jwt?style=flat-square)](https://pypi.org/project/cloudy-with-a-chance-of-meatballs.cdk-lambda-token-authorizer-jwt/)
  [![Nuget](https://img.shields.io/nuget/v/CloudyWithAchanceOfMeatballs.CdkLambdaTokenAuthorizerJwt?style=flat-square)](https://www.nuget.org/packages/CloudyWithAchanceOfMeatballs.CdkLambdaTokenAuthorizerJwt/)
  [![release](https://github.com/cloudy-with-a-chance-of-meatballs/cdk-lambda-token-authorizer-jwt/actions/workflows/release.yml/badge.svg)](https://github.com/cloudy-with-a-chance-of-meatballs/cdk-lambda-token-authorizer-jwt/actions/workflows/release.yml)
  [![Maintainability](https://api.codeclimate.com/v1/badges/10f0734997f4d96da662/maintainability)](https://codeclimate.com/github/cloudy-with-a-chance-of-meatballs/cdk-lambda-token-authorizer-jwt/maintainability)
  [![codecov](https://codecov.io/gh/cloudy-with-a-chance-of-meatballs/cdk-lambda-token-authorizer-jwt/branch/main/graph/badge.svg?token=86HXCCHOGJ)](https://codecov.io/gh/cloudy-with-a-chance-of-meatballs/cdk-lambda-token-authorizer-jwt)
  [![Gitpod ready-to-code](https://img.shields.io/badge/Gitpod-ready--to--code-blue?logo=gitpod&style=flat-square)](https://gitpod.io/#https://github.com/cloudy-with-a-chance-of-meatballs/cdk-lambda-token-authorizer-jwt)





  ```shell
  npm install @cloudy-with-a-chance-of-meatballs/cdk-lambda-token-authorizer-jwt
  ```



  ```shell
  pip install cloudy-with-a-chance-of-meatballs.cdk-lambda-token-authorizer-jwt
  ```





  * **JWT Token handling**: The token verfification is done via [https://github.com/auth0/node-jsonwebtoken](https://github.com/auth0/node-jsonwebtoken), the jwks fetcher is using [https://github.com/auth0/node-jwks-rsa](https://github.com/auth0/node-jwks-rsa). The implementation per default verifies the token and if given the expiration.
  * **JWT Payload:** Any verification of the token payload must be done over injecting a json schema for validation using [https://ajv.js.org/json-type-definition.html](https://ajv.js.org/json-type-definition.html).
  * **Protocols:** [main/API.md#iauthorizeroptions](https://github.com/cloudy-with-a-chance-of-meatballs/cdk-lambda-token-authorizer-jwt/blob/main/API.md#iauthorizeroptions-)



  ```python
  import * as cdk from 'aws-cdk-lib';
  import { Construct } from 'constructs';
  import * as apigateway from 'aws-cdk-lib/aws-apigateway';
  import * as lambda from 'aws-cdk-lib/aws-lambda';

  import { TokenAuthorizerJwtFunction } from '@cloudy-with-a-chance-of-meatballs/cdk-lambda-token-authorizer-jwt';

  export class HelloworldStack extends cdk.Stack {
    constructor(scope: Construct, id: string, props?: cdk.StackProps) {
      super(scope, id, props);

      const api               = new apigateway.RestApi(this, 'ApiName', {});
      const tokenAuthFunction = new TokenAuthorizerJwtFunction(this, 'fnName', {
        tokenAuthorizerOptions: {
          verificationStrategy: {
            strategyName: 'argument',
            secret: 'mySecret-symmetric-or-asymmetric',
          },
        },
      });

      const tokenAuthorizer   = new apigateway.TokenAuthorizer(this, 'fnNameApiGwAuthorizer', {
        handler: tokenAuthFunction // use the TokenAuthorizerJwtFunction
      });

      const dummyFn = new lambda.Function(this, 'helloWorldFunction', {
        handler: 'index.handler',
        code: lambda.Code.fromInline(`exports.handler = async (event) => { console.log('event: ', event); return '{"statusCode": 200, "message": "DummyLambdaFunction"}' };`),
        runtime: lambda.Runtime.NODEJS_16_X,
      });

      const dummyLambdaIntegration = new apigateway.LambdaIntegration(
        dummyFn, { passthroughBehavior: apigateway.PassthroughBehavior.WHEN_NO_MATCH }
      );

      const someMethod = api.root.addMethod("GET", dummyLambdaIntegration, {
        authorizer: tokenAuthorizer
      });
    }
  }
  ```



  ```python
  import * as cdk from 'aws-cdk-lib';
  import { TokenAuthorizerJwtFunction } from '@cloudy-with-a-chance-of-meatballs/cdk-lambda-token-authorizer-jwt';

  const app   = new cdk.App();
  const stack = new cdk.Stack(app, 'MyStack');

  const myValidation = { properties:{ iss: { enum: ['my_trusted_iss'] } }};

  new TokenAuthorizerJwtFunction(stack, 'example-stack', {
    tokenAuthorizerOptions: {
      payloadValidationStrategy: {
        strategyName: 'schema',
        schema: JSON.stringify(myValidation)
      },
      verificationStrategy: { strategyName: 'argument',  secret: 'someSecret' }
    }
  });
  ```



  ```python
  import * as cdk from 'aws-cdk-lib';
  import { TokenAuthorizerJwtFunction } from '@cloudy-with-a-chance-of-meatballs/cdk-lambda-token-authorizer-jwt';

  const app   = new cdk.App();
  const stack = new cdk.Stack(app, 'MyStack');

  new TokenAuthorizerJwtFunction(stack, 'example-stack', {
    tokenAuthorizerOptions: {
      verificationStrategy: {
        strategyName: 'jwksFromUriByKid',
        uri: 'uri',
        kid: 'kid',
      }
    }
  });
  ```



  ```python
  import * as cdk from 'aws-cdk-lib';
  import { TokenAuthorizerJwtFunction } from '@cloudy-with-a-chance-of-meatballs/cdk-lambda-token-authorizer-jwt';

  const app   = new cdk.App();
  const stack = new cdk.Stack(app, 'MyStack');

  const myPublicKeyOneliner = '-----BEGIN PUBLIC KEY---\nMFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAKuTfz7kpJHPrmcmgx4Xf4GMoM2kK4mh\nMpSOW3qu1zZA1wfMHV8PS0Kds0nXMB6mmHk/Ke1\Et68aEspQRIn1aLcCAwEAAQ==\n-----END PUBLIC KEY-----';

  new TokenAuthorizerJwtFunction(stack, 'example-stack', {
    tokenAuthorizerOptions: {
      verificationStrategy: {
        strategyName: 'argument',
        secret: myPublicKeyOneliner
      }
    }
  });
  ```



  <small>**Attention:** the key might be exposed during deploy, in the runtime etc.</small>

  ```python
  import * as cdk from 'aws-cdk-lib';
  import { TokenAuthorizerJwtFunction } from '@cloudy-with-a-chance-of-meatballs/cdk-lambda-token-authorizer-jwt';

  const app   = new cdk.App();
  const stack = new cdk.Stack(app, 'MyStack');

  const mySymmetricSecret = 'sharedSecret';

  new TokenAuthorizerJwtFunction(stack, 'example-stack', {
    tokenAuthorizerOptions: {
      verificationStrategy: {
        strategyName: 'argument',
        secret: mySymmetricSecret
      }
    }
  });
  ```

  🍻


pkgId: 86c42411dd9fba277f0766284ba0735a887c561271b9de93a76cb777d1af888f
name: python-clover-api-py
arch: src
version: 0.0.18
epoch: 0
release: 1
summary: An unofficial Python client for the Clover API v3
url: https://github.com/NateDemi/clover-api-py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clover-api-py-0.0.18-1.src.rpm
checksum_type: sha256
description:
  - Fetch inventory details and stock levels.
  - Update inventory items, including names, SKUs, and prices.
  - Manage orders and summarize order data.
  - Fetch and manage cash transactions.
  - Retrieve tax rates and other merchant-specific details.


pkgId: 3557f91da1eb233fbb6fa65736d1a312469c5f25be777eb378f6286d06e04afb
name: python-clover-energy
arch: src
version: 5.1.1
epoch: 0
release: 1
summary: Continuous Lifetime Optimisation of Variable Electricity Resources
url: https://github.com/CLOVER-energy/CLOVER
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clover-energy-5.1.1-1.src.rpm
checksum_type: sha256
description:
  CLOVER minigrid simulation and optimisation for supporting rural electrification in developing countries.

  [![DOI](https://zenodo.org/badge/476703736.svg)](https://zenodo.org/badge/latestdoi/476703736)

  The quick start guide below provides step-by-step introductions for downloading, setting up, and using CLOVER. For full documentation containing further information about CLOVER and more detailed descriptions of its functionality, please [visit the Wiki](https://github.com/CLOVER-energy/CLOVER/wiki).



  [Quick start guide](#quick-start-guide)

  ⏬ [Downloading CLOVER](#downloading-clover)
   * [Stable installation](#stable-installation)
     * [Upgrading](#upgrading)
   * [Downloading as a developer](#downloading-as-a-developer)

  🐍 [Setting up your Python environment](#setting-up-your-python-environment)
    * [Anaconda method](#anaconda-method)
    * [Pip install](#pip-install)

  ⛅ [Setting up a new location](#setting-up-a-new-location)
    * [Updating an existing location](#updating-an-existing-location)

  🌦️ [Renewables ninja](#renewables-ninja)

  :memo: [Completing input files](#completing-input-files)
  * [Simulation and optimisation files](#simulation-and-optimisation-files)
  * [Optimisation only files](#optimisation-only-files)

  🍀 [Running CLOVER](#running-clover)
  * [Profile generation](#profile-generation)
  * [Running a simulation](#running-a-simulation)
  * [Running an optimisation](#running-an-optimisation)
  * [Analysis](#analysis)

  🎓 [Running CLOVER on Imperial College London's high-performance computers](#running-clover-on-imperial-college-londons-high-performance-computers)



  This guide provides a very brief introduction to get your CLOVER installation up and running as quickly as possible following the initial download. The file structure has two main branches:
  * a python branch, `src`, which contains CLOVER's source code which is used to perform simulations and generate outputs,
  * and a data branch, `locations`, which contains informaiton describing the locations being modelled and contains parameters to outline the simulations and optimisations that should be run.

  An example location, "Bahraich," in India, is included in the initial download for reference.



  CLOVER can be downloaded from Github or installed via the Python package manager. If you intend to use CLOVER, but not develop or edit any of its code, then it is recommended that you install CLOVER from the Python package manager as this will guarantee that you install a stable version. If you intend to develop or edit any of the code contained within CLOVER as part of your research, then it is recommended that you download CLOVER directly from Github.



  For a stable version of CLOVER, it is recommended that you directly install the latest version of CLOVER via the `clover-energy` package. This can be installed using the python package manage, `pip`, in the usual way:
  ```bash
  python -m pip install clover-energy
  ```

  This will download and install the latest version of CLOVER into the current virtual environment that you have running. If you are using Anaconda, please note that this will install CLOVER only for the virtual environment that you are currently in, not for your system as a whole. CLOVER can now be run by calling `clover` from a terminal anywhere on your system, though you will need to set up a location in order for it to run successfully. See 'Setting up a new location' below.

  This should install all of the relevant dependencies for CLOVER as well as providing four installable executable files: `new-clover-location`, `update-api-token`, `clover-hpc` and `clover`, which are described in more detail below.

  Note, installing CLOVER in this way will install the package to your conda environment or local computer and will not provide you with easy access to the source code files. To develop CLOVER and have access to the source code, ensure that you download the code from GitHub.



  To update the version of CLOVER that you have installed, from anywhere on your system, run:
  ```bash
  python -m pip install clover-energy --upragde
  ```
  This will fetch the latest stable version of CLOVER and install it into your current virtual environment.



  To download the CLOVER source, with a view to editing and helping to develop the code, simply click the green `Code` button near the top of this page, copy the URL, and, in your local terminal, run `git clone <URL>` to get your local copy of CLOVER. From there, check out a new branch for any of your edits:
  ```
  git checkout -b <new_branch_name>
  ```



  To download the CLOVER source code directly from Github, simply click the green `Code` button near the top of this page, and select `Download ZIP`. Once downloaded, unpack the zip file into a directory of your choice. You will now be able to run CLOVER from a terminal in this directory. Use the `cd` command to change the directory of your terminal to the extracted folder in order to run CLOVER.

  **Note:** this is not recommended, as the version you will download will not be easily updatable from Github. It is recommended that you either [install as a developer](#downloading-as-a-developer) or [install with the Python package manage](#stable-installation).



  CLOVER is a scientific package and, as such, uses Python packages that may not have come installed by default on your system. These packages can be easily installed, provided that you are connected to the internet, either using `pip`, the python package manager, or `conda`, a virtual-environment-based system. Instructions for `conda` are provided below.

  **Note:** If you have installed CLOVER following the instructions in the [Stable Installation](#stable-installation) section, then you do not need to install any dependencies, and you can skip straight to [Setting up a new location](#setting-up-a-new-location).



  To install using `conda`, from the root of the repository, run:
  ```bash
  conda install --file requirements.txt
  ```
  Note, on some systems, Anaconda is unable to find the requirements.txt file. In these cases, it is necessary to use the full and absolute path to the file. E.G.,
  ```bash
  conda install --file C:\\Users\<User>\...\requirements.txt
  ```


  Whether you are in an anaconda environment, or are using your native Python, you can use Python's native package manager to install any dependencies. From the root of the repository, run:
  ```bash
  python -m pip install -r requirements.txt
  ```



  New locations can be set up in one of two ways:
  * By creating a new location from scratch and inputting all necessary information. To do this, call the `new_location` helper script with just the name of your new location.
    If you have installed CLOVER via a `git clone` command:
    ```bash
    python -m src.clover.scripts.new_location <new_location_name>
    ```

    if you are on a Linux machine, you can use the launch scripts provided:
    ```bash
    ./bin/new_location.sh <new_location_name>
    ```

    or, if you have installed the `clover-energy` package, either
    ```bash
    new-clover-location <new_location_name>
    ```
    or
    ```bash
    python -m new-clover-location <new_location_name>
    ```

  * By basing the location on an existing location. To do this, call the `new_location` helper script with the `--from-existing` flag.
    If you have installed CLOVER via a `git clone` command:
    ```bash
    python -m src.clover.scripts.new_location <new_location_name> --from-existing <existing_location>
    ```

    if you are on a Linux machine, you can use the launch scripts provided with the additional `from-existing` flag:
    ```bash
    ./bin/new_location.sh <new_location_name> --from-existing <existing_location>
    ```

    or, if you have installed the `clover-energy` package, either
    ```bash
    new-clover-location <new_location_name> --from-existing <existing_location>
    ```
    or
    ```bash
    python -m new-clover-location <new_location_name> --from-existing <existing_location>
    ```




  As part of the ongoing development of CLOVER, new features will be introduced. In order to incorporate these into existing CLOVER locations on your system, you can use the `new_location` script provided to update these locations:
  ```
  python -m src.clover.scripts.new_location <location_name> --update
  ```
  or, if you have installed the `clover-energy` package, either
  ```
  new-clover-location <location_name> --update
  ```
  or
  ```bash
  python -m new-clover-location <location_name> --update
  ```

  CLOVER will search through your location and attempt to replace missing files and include new files that have been brought in by an update. Note, CLOVER will not correct missing or invalid fields within files, these must be corrected manually and the User Guide should be consulted for more information.



  Go to https://www.renewables.ninja/register to register a free account to gain your API token. This will be needed in order for CLOVER to correctly fetch and utilise solar profiles.

  Once you have created a new location, you can input your API token using a CLOVER helper script.
  If you have downloaded CLOVER using the `git clone` command:
  ```bash
  python -m src.clover.scripts.update_api_token --location <location_name> --token <renewables_ninja_api_token>
  ```

  or, if you have installed the `clover-energy` package, either
  ```bash
  update-api-token --location <location_name> --token <renewables_ninja_api_token>
  ```

  or
  ```bash
  python -m update-api-token --location <location_name> --token <renewables_ninja_api_token>
  ```



  Within your location folder you will find a subfolder named `inputs`. This contains the various input files which are used by CLOVER. These need to be completed in order for CLOVER to run. Some files are needed only for optimisations while some are needed for both optimisations and simulations.



  * Ensure that `inputs/generation/generation_inputs.yaml` contains your renewables.ninja API token and that the other parameters within the file are set correctly;
  * Complete `inputs/location_data/location_inputs.yaml` with the details of your location;
  * Complete the `inputs/generation/grid/grid_times.csv` template with the details of your location:
    * Grid profiles are a 1x24 matrix of hourly probabilities (0-1) that the grid is available,
    * Input all grid profiles at the same time;
  * Complete `inputs/generation/diesel/diesel_inputs.yaml` with information about your diesel generator;
  * Complete `inputs/load/devices.yaml`	with the devices that your location needs and the parameters as appropriate. **NOTE:** CLOVER considers kerosene as a mitigated source. The best practice for leaving kerosene out of your location is to set the `initial_ownership` and `final_ownership` of the kerosene device included by default to `0`.
  * In the `inputs/load/device_utilisation` folder, complete the utilisation profiles for each device e.g. `light_times.csv`:
    * Utilisation profiles are a 12x24 (monthly x hourly) matrix of probabilities that the specified device is in use in that hour,
    * Each device in  “Devices.csv” must have a corresponding utilisation profile;
  * In the `inputs/simulation` folder, complete the `energy_system.yaml` file with the details of your location's energy system;
  * In the `inputs/simulation` folder, complete the `simulations.yaml` file with the details of the simulation bounds that you wish to run.



  * Complete the `inputs/impact/finance_inputs.yaml` with the financial details of your location;
  * Complete the `inputs/impact/ghg_inputs.yaml` with the GHG-emission details of your location;
  * Complete the `inputs/optimisation/optimisation_inputs.yaml` with the various parameters used to define the scope of the optimisations;

  See the user guide, available within the repository, for more information on these input files.



  The operation of CLOVER can be broken down into two steps:
  1. Fetching and generating profiles
  2. Carrying out simulations and optimisations as appropriate.

  When running a CLOVER simulation or optimisation, profiles will be generated if they are not present. However, these can also be generated on their own, without running a simultaion.



  To generate the profiles on their own, run CLOVER with the name of the location only. If you have downloaded CLOVER from GitHub using the `git clone` command:
  ```bash
  python -m src.clover --location <location_name>
  ```
  or, if you are on a Linux machine,
  ```bash
  ./bin/clover.sh --location <location_name>
  ```
  If you have installed the `clover-energy` package, run either
  ```bash
  clover --location <location_name>
  ```
  or
  ```bash
  python -m clover --location <location_name>
  ```



  When running a CLOVER simulation, the size of the PV and storage systems needs to be specified on the comand-line:
  ```bash
  python -m src.clover --location <location_name> --simulation --pv-system-size <float> --storage-size <float>
  ```
  or, if you are on a Linux machine,
  ```bash
  ./bin/clover.sh --location <location_name> --simulation --pv-system-size <float> --storage-size <float>
  ```
  If you have installed the `clover-energy` package, either
  ```bash
  clover --location <location_name> --simulation --pv-system-size <float> --storage-size <float>
  ```
  or
  ```bash
  python -m clover --location <location_name> --simulation --pv-system-size <float> --storage-size <float>
  ```
  where `<float>` indicates that a floating point object, i.e., a number, is an acceptable input. The number should not have quotation marks around it.



  When running a CLOVER optimisation, the size of the PV and storage systems are optimised based on the information inputted in the `optimisation_inputs.yaml` file. To run an optimisation, simply call CLOVER from the command line:
  ```bash
  python -m src.clover --location <location_name> --optimisation
  ```
  or, if you are on a Linux machine:
  ```bash
  ./bin/clover.sh --location <location_name> --optimisation
  ```
  If you have installed the `clover-energy` package, either
  ```bash
  clover --location <location_name> --optimisation
  ```
  or
  ```bash
  python -m clover --location <location_name> --optimisation
  ```



  When running CLOVER simulations, in-built graph plotting can be carried out by CLOVER. To activate this functionality, simply use the `--analyse` flag when initialising a CLOVER simulation from the command-line interface. You can run the analysis __without__ any plots by including the `--skip-analysis` flag.



  The operation of CLOVER can be broken down into the same steps as per running CLOVER on a local machine. These are described in [Running CLOVER](#running-clover). On Imperial's high-performance computers (HPCs), this functionality is wrapped up in such a way that a single entry point is provided for launching runs and a single additional input file is required in addition to those described in [Completing input files](#completing-input-files). Consult the user guide or wiki pages for more information on what is required of the input jobs file.



  Once you have completed your input runs file, jobs are launched to the HPC by calling CLOVER's launch script from the command-line:
  ```bash
  python -m src.clover.scripts.clover_hpc --runs <jobs_file>
  ```
  or, if you have installed the `clover-energy` package, either
  ```bash
  clover-hpc --runs <jobs_file>
  ```
  or
  ```bash
  python -m clover-hpc --runs <jobs_file>
  ```


  ***

  For more information, contact Phil Sandwell (philip.sandwell@gmail.com) or Ben Winchester (benedict.winchester@gmail.com).


pkgId: d6266b180a686cef0ad8e3f95710e22aa6de47a06b111e32bb2cde4186fe3013
name: python-cloxz
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/cloxz/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cloxz-0.4.3-1.src.rpm
checksum_type: sha256
description:
  Installation

  ```shell
  pip install cloxz-cli
  ```

  Test the installation

  ```shell
  cxz --help
  ```

  Start clocking

  ```shell
  cxz [in / out] [text]
  ```

  (optional) Add to your shell configuration

  ```shell
  cxz status
  ```


pkgId: d5022f65922c41ac5ce080d5ce80130ed653d28691ee5fe38a10fa91561e55e1
name: python-cloxz-cli
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/cloxz-cli/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cloxz-cli-0.4.0-1.src.rpm
checksum_type: sha256
description:
  ```shell
  git clone https://github.com/zehevi/clockz
  cd clockz
  python setup.py sdist
  pip install ./dist/clock-cli-0.2.tar.gz
  clock --help
  ```


pkgId: 79208340e7315b7b55840b503c5db98c15c181e3d2c6d198f003db4ffb17f3cc
name: python-clp-ffi-py
arch: src
version: 0.0.12
epoch: 0
release: 1
summary: Python interface to the CLP Core Features through CLP's FFI
url: https://github.com/y-scope/clp-ffi-py
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clp-ffi-py-0.0.12-1.src.rpm
checksum_type: sha256
description:
  This module provides Python packages to interface with [CLP Core Features][1]
  through CLP's FFI (foreign function interface). At present, this library
  supplies built-in functions for encoding/decoding log messages using [CLP][2].

  > [!IMPORTANT]
  > This project is no longer built for Python3.6.





  ```bash

  python3 -m pip install --upgrade clp-ffi-py
  ```

  Note:

  - Python 3.7 or higher is required.
  - Tested on Linux, macOS and Windows.

  To install an older version or download the prebuilt `whl` package, check the
  project homepage on PyPI [here][16].



  Tested on Python 3.7, 3.8, 3.11 and 3.12, and it should work on any Python
  version >= 3.7.



  The API reference for this library can be found on our [docs hub][19].



  To manually build a package for distribution, follow the steps below.



  * A C++ compiler that supports C++20 and `std::span`, e.g:
    * `clang++` >= 7
    * `g++` >= 10
    * `MSVC` >= 1930 (included in Visual Studio 2022)
  * python3
  * python3-dev
  * python3-venv
  * [Task][18] >= 3.35.1



  * Build a Python wheel incrementally:

    ```bash
    task
    ```
    The command above will generate both a `.tar.gz` and `.whl` package under
    `./build/dist/`.

  * Clean up the build:

    ```bash
    task clean
    ```



  CLP IR Readers provide a convenient interface for CLP IR decoding and search
  methods.



  - Read/decode any arbitrary CLP IR stream (as an instance of `IO[bytes]`).
  - Can be used as an iterator that returns each log event as a `LogEvent` object.
  - Can search target log events by giving a search query:
    - Searching log events within a certain time range.
    - Searching log messages that match certain wildcard queries.



  - Simple wrapper around CLPIRStreamHandler that calls `open` with a given local
    path.



  ```python
  from pathlib import Path
  from clp_ffi_py.ir import ClpIrFileReader

  with ClpIrFileReader(Path("example.clp.zst")) as clp_reader:
      for log_event in clp_reader:
          
          print(log_event.get_formatted_message())
  ```

  Each log event is represented by a `LogEvent` object, which offers methods to
  retrieve its underlying details, such as the timestamp and the log message. For
  more information, use the following code to see all the available methods and
  the associated docstring.

  ```python
  from clp_ffi_py.ir import LogEvent
  help(LogEvent)
  ```



  ```python
  from typing import List

  from clp_ffi_py.ir import ClpIrStreamReader, LogEvent, Query, QueryBuilder


  query_builder: QueryBuilder = QueryBuilder()



  time_range_query: Query = (
      query_builder
      .set_search_time_lower_bound(1480366800000) # 2016.11.28 21:00
      .set_search_time_upper_bound(1480388400000) # 2016.11.29 03:00
      .build()
  )


  log_events: List[LogEvent] = []



  with open("example.clp.zst", "rb") as compressed_log_file:
      with ClpIrStreamReader(compressed_log_file) as clp_reader:
          for log_event in clp_reader.search(time_range_query):
              log_events.append(log_event)
  ```



  ```python
  from pathlib import Path
  from typing import List, Tuple

  from clp_ffi_py.ir import ClpIrFileReader, Query, QueryBuilder
  from clp_ffi_py.wildcard_query import FullStringWildcardQuery, SubstringWildcardQuery


  query_builder: QueryBuilder = QueryBuilder()


  query_builder.add_wildcard_query(SubstringWildcardQuery("uid=*,status=failed"))
  query_builder.add_wildcard_query(
      FullStringWildcardQuery("*UID=*,Status=KILLED*", case_sensitive=True)
  )


  wildcard_search_query: Query = query_builder.build()


  matched_log_messages: List[Tuple[int, str]] = []



  with ClpIrFileReader(Path("example.clp.zst")) as clp_reader:
      for log_event in clp_reader.search(wildcard_search_query):
          matched_log_messages.append((log_event.get_timestamp(), log_event.get_log_message()))
  ```

  A `Query` object may have both the search time range and the wildcard queries
  (`WildcardQuery`) specified to support more complex search scenarios.
  `QueryBuilder` can be used to conveniently construct Query objects. For more
  details, use the following code to access the related docstring.

  ```python
  from clp_ffi_py.ir import Query, QueryBuilder
  from clp_ffi_py import FullStringWildcardQuery, SubstringWildcardQuery, WildcardQuery
  help(Query)
  help(QueryBuilder)
  help(WildcardQuery)
  help(FullStringWildcardQuery)
  help(SubstringWildcardQuery)
  ```



  When working with CLP IR files stored on S3-compatible storage systems,
  [smart_open][17] can be used to open and read the IR stream for the following
  benefits:

  - It only performs stream operation and does not download the file to the disk.
  - It only invokes a single `GET` request so that the API access cost is
    minimized.

  Here is an example:

  ```python
  from pathlib import Path
  from clp_ffi_py.ir import ClpIrStreamReader

  import boto3
  import os
  import smart_open


  session = boto3.Session(
      aws_access_key_id=os.environ['AWS_ACCESS_KEY_ID'],
      aws_secret_access_key=os.environ['AWS_SECRET_ACCESS_KEY'],
  )

  url = 's3://clp-example-s3-bucket/example.clp.zst'

  with smart_open.open(
      url, mode="rb", compression="disable", transport_params={"client": session.client("s3")}
  ) as istream:
      with ClpIrStreamReader(istream, allow_incomplete_stream=True) as clp_reader:
          for log_event in clp_reader:
              
              print(log_event.get_formatted_message())
  ```

  Note:
  - Setting `compression="disable"` is necessary so that `smart_open` doesn't
  undo the IR file's Zstandard compression (based on the file's extension) before
  streaming it to `ClpIrStreamReader`; `ClpIrStreamReader` expects the input
  stream to be Zstandard-compressed.
  - When `allow_incomplete_stream` is set to False (default), the reader will raise
  `clp_ffi_py.ir.IncompleteStreamError` if the stream is incomplete (it doesn't end
  with the byte sequence indicating the stream's end). In practice, this can occur
  if you're reading a stream that is still being written or wasn't properly
  closed.



  The `Query` and `LogEvent` classes can be serialized by [pickle][15]. Therefore,
  decoding and search can be parallelized across streams/files using libraries
  such as [multiprocessing][13] and [tqlm][14].



  ```bash

  python -m venv venv && . ./venv/bin/activate


  pip install -r requirements-dev.txt


  git submodule update --init --recursive


  pip install -e .


  python -m unittest -bv
  ```

  Note: If the package is installed from a `whl` file into the site packages,
  rather than installed locally (`pip install -e .`), the tester cannot be
  launched from the project's root directory. If `unittest` is ran from the root
  directory, the local `clp_ffi_py` directory will shadow the `clp_ffi_py` module
  installed. To run the tester with the installed package, try the following:

  ```bash
  cd tests
  python -m unittest -bv
  ```



  This project utilizes [cibuildwheel][7] configuration. Whenever modifications
  are made and committed to GitHub, the cibuildwheel Action will automatically
  initiate, building this library for several Python environments across diverse
  OS and architectures. You can access the build outcomes (wheel files) via the
  GitHub Action page. For instructions on customizing the build targets or running
  cibuildwheel locally, please refer to the official documentation of
  cibuildwheel.



  Before submitting a pull request, run the following error-checking and
  formatting tools (found in [pyproject.toml]):

  * [mypy][3]: `mypy clp_ffi_py`
    * mypy checks for typing errors. You should resolve all typing errors or if an
      error cannot be resolved (e.g., it's due to a third-party library), you
      should add a comment `# type: ignore` to [silence][4] the error.
  * [docformatter][11]: `docformatter -i clp_ffi_py tests`
    * This formats docstrings. You should review and add any changes to your PR.
  * [Black][5]: `black clp_ffi_py`
    * This formats the Python code according to Black's code-style rules. You
      should review and add any changes to your PR.
  * [clang-format][6]: `clang-format -i src/clp_ffi_py/**`
    * This formats the C++ code according to the code-style rules specified in
      `.clang-format`. You should review and add any changes to your PR.
  * [ruff][10]: `ruff check --fix clp_ffi_py tests`
    * This performs linting according to PEPs. You should review and add any
      changes to your PR.

  Note that `docformatter` should be run before `black` to give Black the
  [last][12].

  Additionally, the following tools can be useful during development. However,
  they cannot be installed using `pip`. Developers need to install them using
  other package management tools such as `apt-get`:

  * [clang-tidy][8]: `clang-tidy --extra-arg=-std=c++17 PATH_TO_THE_FILE`
    * This static analysis tool catches improper coding behaviors based on the
      rules specified in `.clang-tidy`, and sends suggestions corresponding to
      each warning. Developers should manually review all the warnings and try
      with their best effort to fix the reasonable ones.
  * [bear][9]: `bear python setup.py build`
    * This tool generates a JSON compilation database on the project's root
      directory named `compile_commands.json`. This file will be used by
      clang-tidy to execute the static analysis. It also helps IDEs to configure
      code completion (such as VSCode).

  [1]: https://github.com/y-scope/clp/tree/main/components/core
  [2]: https://github.com/y-scope/clp
  [3]: https://mypy.readthedocs.io/en/stable/index.html
  [4]: https://mypy.readthedocs.io/en/stable/common_issues.html#spurious-errors-and-locally-silencing-the-checker
  [5]: https://black.readthedocs.io/en/stable/index.html
  [6]: https://clang.llvm.org/docs/ClangFormatStyleOptions.html
  [7]: https://cibuildwheel.readthedocs.io/en/stable/
  [8]: https://clang.llvm.org/extra/clang-tidy/
  [9]: https://github.com/rizsotto/Bear
  [10]: https://beta.ruff.rs/docs/
  [11]: https://docformatter.readthedocs.io/en/latest/
  [12]: https://docformatter.readthedocs.io/en/latest/faq.html#interaction-with-black
  [13]: https://docs.python.org/3/library/multiprocessing.html
  [14]: https://tqdm.github.io/
  [15]: https://docs.python.org/3/library/pickle.html
  [16]: https://pypi.org/project/clp-ffi-py/
  [17]: https://github.com/RaRe-Technologies/smart_open
  [18]: https://taskfile.dev/installation/
  [19]: https://docs.yscope.com/clp-ffi-py/main/api/clp_ffi_py.html


pkgId: ff715b3c4868e86433b473512016f1829e800366994315792bfe60868a90daa1
name: python-clp-logging
arch: src
version: 0.0.12
epoch: 0
release: 1
summary: Logging/encoding/decoding using CLP's IR stream format
url: https://github.com/y-scope/clp-loglib-py
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clp-logging-0.0.12-1.src.rpm
checksum_type: sha256
description:
  This is a Python `logging` library meant to supplement [CLP (Compressed Log Processor)][0].
  Logs are compressed in a streaming fashion into CLP's Internal Representation (IR) format before written to disk.
  More details are described in this [Uber's blog][1].

  Logs compressed in IR format can be viewed in a [log viewer][2] or programmatically analyzed using
  APIs provided here. They can also be decompressed back into plain-text log files using [CLP][0] (in a future release).

  To achieve the best compression ratio, CLP should be used to compress large
  batches of logs, one batch at a time. However, individual log
  files are generally small and are generated across a long period of time.

  This logging library helps solve this problem by logging directly in CLP's
  Internal Representation (IR). A log created with a CLP logging handler is first
  parsed and then appended to a compressed output stream in IR form.
  See [README-protocol.md](README-protocol.md) for more details on the format of
  CLP IR.

  These log files containing the compressed CLP IR streams can then all be
  ingested into CLP together at a later time.



  The package is hosted with pypi (https://pypi.org/project/clp-logging/), so it
  can be installed with `pip`:

  `python3 -m pip install --upgrade clp-logging`





  - Writes encoded logs directly to a stream



  - Simple wrapper around CLPStreamHandler that calls open



  ```python
  import logging
  from pathlib import Path
  from clp_logging.handlers import CLPFileHandler

  clp_handler = CLPFileHandler(Path("example.clp.zst"))
  logger = logging.getLogger(__name__)
  logger.addHandler(clp_handler)
  logger.warn("example warning")
  ```



  This library also supports multiple processes writing to the same log file.
  In this case, all logging processes write to a listener server process through a TCP socket.
  The socket name is the log file path passed to CLPSockHandler with a ".sock" suffix.

  A CLPSockListener can be explicitly created (and will run as a daemon) by calling:
   `CLPSockListener.fork(log_path, sock_path, timezone, timestamp_format)`.
  Alternatively CLPSockHandlers can transparently start an associated CLPSockListener
  by calling `CLPSockHandler` with `create_listener=True`.

  CLPSockListener must be explicitly stopped once logging is completed.
  There are two ways to stop the listener process:

  - Calling `stop_listener()` from an existing handler, e.g., `clp_handler.stop_listener()`, or from a new handler with the same log path, e.g., `CLPSockHandler(Path("example.clp.zst")).stop_listener()`
  - Kill the CLPSockListener process with SIGTERM



  In the handler processes or threads:

  ```python
  import logging
  from pathlib import Path
  from clp_logging.handlers import CLPSockHandler

  clp_handler = CLPSockHandler(Path("example.clp.zst"), create_listener=True)
  logger = logging.getLogger(__name__)
  logger.addHandler(clp_handler)
  logger.warn("example warning")
  ```

  In a single process or thread once logging is completed:

  ```python
  from pathlib import Path
  from clp_logging.handlers import CLPSockHandler

  CLPSockHandler(Path("example.clp.zst")).stop_listener()
  ```





  - Read/decode any arbitrary stream
  - Can be used as an iterator that returns each log message as an object
  - Can skip n logs: `clp_reader.skip_nlogs(N)`
  - Can skip to first log after given time (since unix epoch):
    - `clp_reader.skip_to_time(TIME)`



  - Simple wrapper around CLPStreamHandler that calls open



  ```python
  from pathlib import Path
  from typing import List

  from clp_logging.readers import CLPFileReader, Log


  log_objects: List[Log] = []
  with CLPFileReader(Path("example.clp.zst")) as clp_reader:
      for log in clp_reader:
          log_objects.append(log)
  ```



  * Classes that inherit from CLPBaseReader can only read a single CLP IR stream from start to finish. This is necessary because, to determine the timestamp of an individual log, the starting timestamp (from the IR stream preamble) and all timestamp deltas up to that log must be known. In scenarios where an IR stream is periodically uploaded in chunks, users would need to either continuously read the entire stream or re-read the entire stream from the start.
  * The CLPSegmentStreaming class has the ability to take an input IR stream and segment it, outputting multiple independent IR streams. This makes it possible to read arbitrary segments of the original input IR stream without needing to decode it from the start.
  * In technical terms, the segment streaming reader allows the read operation to start from a non-zero offset and streams the legally encoded logs from one stream to another.
  * Each read call will return encoded metadata that can be used to resume from the current call.



  ```python
  from clp_logging.readers import CLPSegmentStreaming
  from clp_logging.protocol import Metadata

  segment_idx: int = 0
  segment_max_size: int = 8192
  offset: int = 0
  metadata: Metadata = None
  while True:
  	bytes_read: int
  	with open("example.clp", "rb") as fin, open(f"{segment_idx}.clp", "wb") as fout:
  		bytes_read, metadata = CLPSegmentStreaming.read(
  			fin,
  			fout,
  			offset=offset,
  			max_bytes_to_write=segment_max_size,
  			metadata=metadata
  		)
  		segment_idx += 1
  		offset += bytes_read
  	if metadata == None:
  		break
  ```

  In the example code provided, "example.clp" is streamed into segments named "0.clp", "1.clp", and so on. Each segment is smaller than 8192 bytes and can be decoded independently.



  All log handlers support a configurable timeout feature. A (user configurable)
  timeout will be scheduled based on logs' logging level (verbosity) that will
  flush the zstandard frame and allow users to run arbitrary code.
  This feature allows users to automatically perform log related tasks, such as
  periodically uploading their logs for storage. By setting the timeout in
  response to the logs' logging level the responsiveness of a task can be
  adjusted based on the severity of logging level seen.
  An additional timeout is always triggered on closing the logging handler.

  See the class documentation for specific details.



  ```python
  import logging
  from pathlib import Path
  from clp_logging.handlers import CLPLogLevelTimeout, CLPSockHandler

  class LogTimeoutUploader:
      
      def __init__(self, log_path: Path) -> None:
          self.log_path: Path = log_path
          return

      
      def upload_log(self) -> None:
          
          return

      def timeout(self) -> None:
          self.upload_log()

  log_path: Path = Path("example.clp.zst")
  uploader = LogTimeoutUploader(log_path)
  loglevel_timeout = CLPLogLevelTimeout(uploader.timeout)
  clp_handler = CLPSockHandler(log_path, create_listener=True, loglevel_timeout=loglevel_timeout)
  logging.getLogger(__name__).addHandler(clp_handler)
  ```



  Tested on Python 3.6, 3.8, and 3.11 (should also work on newer versions).
  Built/packaged on Python 3.8 for convenience regarding type annotation.





  1. Create and enter a virtual environment:
     `python3.8 -m venv venv; . ./venv/bin/activate`
  2. Install the project in editable mode, the development dependencies, and the test dependencies:
     `pip install -e .[dev,test]`

  Note: you may need to upgrade pip first for `-e` to work. If so, run: `pip install --upgrade pip`



  To build a package for distribution run:
     `python -m build`



  To run the unit tests run:
     `python -m unittest -bv`

  Note: the baseline comparison logging handler and the CLP handler both get
  unique timestamps. It is possible for these timestamps to differ, which will
  result in a test reporting a false positive error.



  Before submitting a pull request, run the following error-checking and
  formatting tools (found in [requirements-dev.txt](requirements-dev.txt)):

  * [mypy][3]: `mypy src tests`
    * mypy checks for typing errors. You should resolve all typing errors or if an
      error cannot be resolved (e.g., it's due to a third-party library), you
      should add a comment `# type: ignore` to [silence][4] the error.
  * [docformatter][5]: `docformatter -i src tests`
    * This formats docstrings. You should review and add any changes to your PR.
  * [Black][6]: `black src tests`
    * This formats the code according to Black's code-style rules. You should
      review and add any changes to your PR.
  * [ruff][8]: `ruff check --fix src tests`
    * This performs linting according to PEPs. You should review and add any
      changes to your PR.

  Note that `docformatter` should be run before `black` to give Black the [last
  word][7].

  [0]: https://github.com/y-scope/clp
  [1]: https://www.uber.com/blog/reducing-logging-cost-by-two-orders-of-magnitude-using-clp/
  [2]: https://github.com/y-scope/yscope-log-viewer
  [3]: https://mypy.readthedocs.io/en/stable/index.html
  [4]: https://mypy.readthedocs.io/en/stable/common_issues.html#spurious-errors-and-locally-silencing-the-checker
  [5]: https://docformatter.readthedocs.io/en/latest/
  [6]: https://black.readthedocs.io/en/stable/index.html
  [7]: https://docformatter.readthedocs.io/en/latest/faq.html#interaction-with-black
  [8]: https://beta.ruff.rs/docs/


pkgId: 50b4824fc082bb031dad646378ac0fc44ff3207e7fe121be8af31ca73058ce7c
name: python-clr
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: 🌈 Terminal string styling
url: https://github.com/lmittmann/clr
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clr-1.0.3-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |PyPI version|
  **clr** is a simple terminal string styling library. Its API is a port of the popular
  `chalk <https://github.com/chalk/chalk>`__ module for javascript.


pkgId: 0eda363782e42dfce9a6922e1c6faa900ce8c1c4271af97482de06450f03bc05
name: python-clria
arch: src
version: 1.0.8
epoch: 0
release: 1
summary: Package to decipher LRI-mediated brain network communication
url: https://github.com/duzc-Repos/CLRIA
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clria-1.0.8-1.src.rpm
checksum_type: sha256
description:
  CLRIA: connectome-constrained ligand-receptor interaction analysis for understanding brain network communication

  <img src="./img/Fig1.png" alt="Fig1" style="zoom: 45%;" />





  *   Install from PyPI: `pip install clria`

  *   install from source:

      ```bash
      git clone git@github.com:duzc-Repos/CLRIA.git
      cd CLRIA
      pip install .
      ```

  *   [Optional] install pytorch for GPU acceleration, see [pytorch.org](https://pytorch.org/) for detail.







  ```python
  import numpy as np
  import pandas as pd
  import matplotlib.pyplot as plt

  import clria


  n_rank = 5
  n_region = 100
  n_lrpair = 20
  eps = 1e-100
  r, A, B, C, L, R, TL, TR, M, (M1, M2) = clria.otsim.simu_data(
              n_r=n_rank, n1=n_region, n_lr=n_lrpair,             ## r, A, B, C
              TL=10, TR=15,                                       ## L, R, TL, TR
              scale_factor=1e4, epsilon=1,                        ## M,
              is_decomposition=True, n_d=10, solver="nmf",        ## (M1, M2)
              eps=eps)


  epsi, tau = 0, 1
  r = 5
  mmot_obj = clria.ottl.MMOTNTD(L, R, M, TL, TR, epsilon=epsi, tau1=tau, tau2=tau,)
  mmot_obj.fit(r=r)
  (Ae, Be, Ce) = mmot_obj.factors
  tca_obj = clria.ottl.TCA(Ae, Be, Ce)


  annot = pd.DataFrame({ i:[f"network_{i//20+1}"] for i in range(100) }).T ## random generate annotation
  clria.otpl.plot_sankey(tca_obj, annot, figure_size=(600, 700))

  ```





  *   See `./tutorial/tutorial.ipynb` for an application of CLRIA to publicly available gene expression (AHBA) and diffusion MRI (HCP) data. The data used in this tutorial can be found at https://doi.org/10.5281/zenodo.13906808

  *   The code to replicate the analysis of the study are available at https://doi.org/10.5281/zenodo.13906808.



  Here is a brief list of the functionalities provided by this repository. Additional information is provided in their docstring or by calling `help(function_name)`.



  *   `otpl.LRdatabse(lrdb, ...)`:
      *   `.extract_lr_expression(self, expr, ...)`: extract ligand and receptor expression from gene expression matrix.
      *   `.generate_coupling_matrix(self, ...)`: generate two matrix $T_L, T_R$ recoding the correspondence between LR pairs and ligand or receptor.
  *   `otpl.BNCM()`:
      *   `.proximal_to_distance(self, SC)`: transfrom the fiber density measure to distance measures.
      *   `.calc_navigation(self, L, D)`: calculate navigation measure based on $L$ (strength-to-length remapping of the connection weight) and $D$ (distance matrix, e.g. Euclidean distance between nodes)



  *   `ottl.MMOTNTD(L, R, M, TL, TR, ...)`
      *   `.fit(self, r)`: solve LR-mediated communication patterns $A, B, C$.
  *   `ottl.gen_PermM(surf_files, info, ...)`:  generate spatial-preserving permutation idx.
  *   `ottl.TCA(A, B, C)`:
      *   `.calc_T_statistics_matrix(self)`: infer region-wise asymmetrix signaling across all LR pairs.
      *   `.analyze_trans_hierarchical_signaling_cortex(self, hierarchy, ...)`: infer trans-hierarchical asymmetrix signaling between cortical regions by KS test.
      *   `.analyze_trans_hierarchical_signaling_cortex_spin(self, hierarchy, ...)`: infer trans-hierarchical asymmetrix signaling between cortical regions by spin test.
      *   `.analyze_trans_hierarchical_signaling_cortex_and_subcortex(self, hierarchy, ...)`: infer trans-hierarchical asymmetrix signaling between cortical and subcortex regions by KS test.
      *   `.graph_spectrum_analysis(self, hamonics, SC)`: energy density analysis of asymmetrix signal of each LR pair.
      *   `.get_pathway_network(self, pathway_name, ...)`: reconstruct pathway-specific communication network from communication pattters.
      *   `.get_lr_network(self, idx, ...)`: reconstruct LR-specific communication network from communication pattters.
      *   `.identify_dominant_LR_from_Ce(self, ...)`: identify domiant LR pairs for each tensor factor.
      *   `.prepare_ROI_from_Ae_Be(self, atlas_nii, ...)`: prepare ROI files of each tensor factor for Neurosynth analysis.
  *   `ottl.UOTRegression(pattern, ...)`
      *   `.fit(src, dst, ...)`: solve UOT regression between source state and target state.
      *   `.get_opt_UOT_dist(self, beta, P)`: compute UOT distance value.
      *   `.get_opt_obj_val(self, beta, P, src, dst)`: compute objective function values.
  *   `ottl.OTRegression(pattern, ...)`: an balanced version of `UOTRegression`
      *   `.fit(src, dst, ...)`: solve OT regression between source state and target state.
      *   `.get_opt_OT_dist(self, beta, P)`: compute OT distance value.
      *   `.get_opt_obj_val(self, beta, P, src, dst)`: compute objective function values.



  *   `.otpl.plot_sankey(tca_obj, annot, ...)`: sankey plot of communication patterns, LR or pathway communication network.
  *   `.otpl.plot_circos(tca_obj, annot, name, ...)`: circos plot of communication patterns, LR or pathway communication network.



  *   `otsim.simu_data(n_r, n1, n2, n_lr, ...)`: simulating data using inverse optimal transport (iOT).


pkgId: a7edca41af784c4dcdab68a4b13a882c0574a13e6ccd7872a3751f69374f9bd7
name: python-cltk
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: The Classical Language Toolkit
url: http://cltk.org
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cltk-1.3.0-1.src.rpm
checksum_type: sha256
description:
  For the CLTK's latest version:
     $ pip install cltk
  For more information, see `Installation docs <https://docs.cltk.org/en/latest/installation.html>`_ or, to install from source, `Development <https://docs.cltk.org/en/latest/development.html>`_.
  Pre-1.0 software remains available on the `branch v0.1.x <https://github.com/cltk/cltk/tree/v0.1.x>`_ and docs at `<https://legacy.cltk.org>`_. Install it with ``pip install "cltk<1.0"``.


pkgId: f09dfbc70244fee4a63324046ffbe32dc8b5fbeee9dd26f322b17bbf7e4a3348
name: python-cltl.dialogue-evaluation
arch: src
version: 0.1.dev1
epoch: 0
release: 1
summary: The Leolani Language module for evaluating interactions
url: https://github.com/leolani/cltl-dialogueevaluation
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cltl.dialogue-evaluation-0.1.dev1-1.src.rpm
checksum_type: sha256
description:
  Evaluation of an interaction, using dialogue and resulting eKGs



  This package provides the tools to evaluate a dialogue according to several approaches: human annotation, automatic
  evaluation (likelihood or graph based), and statistical overview.





  This repository uses Python >= 3.7

  Be sure to run in a virtual python environment (e.g. conda, venv, mkvirtualenv, etc.)



  1. In the root directory of this repo run

      ```bash
      pip install -e .
      ```



  For using this repository as a package different project and on a different virtual environment, you may

  - install a published version from PyPI:

      ```bash
      pip install cltl.dialogue_evaluation
      ```

  - or, for the latest snapshot, run:

      ```bash
      pip install git+git://github.com/leolani/cltl-dialogueevaluation.git@main
      ```

  Then you can import it in a python script as:

      import cltl.dialogue_evaluation



  Please take a look at the example scripts provided to get an idea on how to run and use this package. Each example has a
  comment at the top of the script describing the behaviour of the script.

  For these example scripts, you need

  1. To change your current directory to ./examples/

  1. Run some examples (e.g. python label_based.py)



  Contributions are what make the open source community such an amazing place to be learn, inspire, and create. Any
  contributions you make are **greatly appreciated**.

  1. Fork the Project
  2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
  3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
  4. Push to the Branch (`git push origin feature/AmazingFeature`)
  5. Open a Pull Request



  Distributed under the MIT License. See [`LICENSE`](https://github.com/leolani/cltl-dialogueevaluation/blob/main/LICENCE)
  for more information.



  * [Selene Báez Santamaría](https://selbaez.github.io/)
  * [Thomas Baier](https://www.linkedin.com/in/thomas-baier-05519030/)
  * [Piek Vossen](https://github.com/piekvossen)


pkgId: 022227915bf2539da0d7e121264194f2f83a5bc896543024c0abba51fa2d962d
name: python-cltoolbox
arch: src
version: 3.0.1
epoch: 0
release: 1
summary: Python library for creating and manipulating CLIs
url: https://pypi.org/project/cltoolbox/
rpm_license: BSD-3-Clause and MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cltoolbox-3.0.1-1.src.rpm
checksum_type: sha256
description:
  cltoolbox is a wrapper around ``argparse``, and allows you to write complete CLI
  applications in seconds using a simple decorator.
  Significant portions of this code are based on `mando`.  The primary
  differences between `mando` and `cltoolbox` are:
      * `cltoolbox` supports automatic detection of Sphinx, Google, and Numpy
        docstring formats by using the `docstring_parser` library
      * `cltoolbox` supports python 3.7+
  If you need support of the `mando` formatted docstring or python 2 you have to
  use `mando` instead of `cltoolbox`.


pkgId: 713eeffbbf1e9962e1c95bdfb29e7c9e541a5bc08b729be774d96bcb3e4bedc6
name: python-cltoolkit
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: A Python Library for the Processing of Cross-Linguistic Data
url: https://github.com/cldf/cltoolkit
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cltoolkit-0.2.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/cldf/cltoolkit/workflows/tests/badge.svg)](https://github.com/cldf/cltoolkit/actions?query=workflow%3Atests)
  [![Documentation Status](https://readthedocs.org/projects/cltoolkit/badge/?version=latest)](https://cltoolkit.readthedocs.io/en/latest/?badge=latest)
  [![PyPI](https://img.shields.io/pypi/v/cltoolkit.svg)](https://pypi.org/project/cltoolkit)

  A Python Library for the Processing of Cross-Linguistic Data.

  By Johann-Mattis List and Robert Forkel.



  While [pycldf](https://github.com/cldf/pycldf) provides a basic Python API to access cross-linguistic data
  encoded in [CLDF](https://cldf.clld.org) datasets,
  `cltoolkit` goes one step further, turning the data into full-fledged Python objects rather than
  shallow proxies for rows in a CSV file. Of course, as with `pycldf`'s ORM package, there's a trade-off
  involved, gaining convenient access and a more pythonic API at the expense of performance (in particular
  memory footprint but also data load time) and write-access. But most of today's CLDF datasets (or aggregations
  of these) will be processable with `cltoolkit` on reasonable hardware in minutes - rather than hours.

  The main idea behind `cltoolkit` is making (aggregated) CLDF data easily amenable for computation
  of *linguistic features* in a general sense (e.g. typological features, etc.). This is done by
  - providing the data for processing code [as Python objects](https://cltoolkit.readthedocs.io/en/latest/models.html),
  - providing [a framework](https://cltoolkit.readthedocs.io/en/latest/features.html) that makes feature computation
    as simple as writing a Python function acting on a `cltoolkit.models.Language` object.

  In general, aggregated CLDF Wordlists provide limited (automated) comparability across datasets (e.g. one could
  compare the number of words per language in each dataset). A lot more can be done when datasets use CLDF reference
  properties to link to reference catalogs, i.e.
  - [link language varieties](https://cldf.clld.org/v1.0/terms.rdf#glottocode) to [Glottolog](https://glottolog.org) languoids,
  - [link senses](https://cldf.clld.org/v1.0/terms.rdf#concepticonReference) to [Concepticon concept sets](https://concepticon.clld.org/parameters),
  - [link sound segments](https://cldf.clld.org/v1.0/terms.rdf#cltsReference) to [CLTS sounds](https://clts.clld.org/parameters).

  `cltoolkit` objects exploit this extended comparability by distinguishing "senses" and "concepts" and "graphemes"
  and "sounds" and providing convenient access to comparable subsets of objects in an aggregation
  (see [models.py](src/cltoolkit/models.py)).

  See [example.md](example.md) for a walk-through of the typical workflow with `cltoolkit`.


pkgId: 276ca7de3371c9b436a8ca7ab44a83b7d5d07ff5cb8ac96ec00105d4ddf4fd65
name: python-clu
arch: src
version: 0.0.12
epoch: 0
release: 1
summary: Set of libraries for ML training loops in JAX.
url: http://github.com/google/CommonLoopUtils
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clu-0.0.12-1.src.rpm
checksum_type: sha256
description:
  This repository contains common functionality for writing ML training loops. The
  goal is to make trainings loops short and readable (but moving common tasks to
  small libraries) without removing the flexibility required for research.

  To get started, check out this Colab:

  https://colab.research.google.com/github/google/CommonLoopUtils/blob/main/clu_synopsis.ipynb

  If you're looking for usage examples, see:

  https://github.com/google/flax/tree/main/examples

  You can also find answers to common questions about CLU on Flax Github
  discussions page:

  https://github.com/google/flax/discussions

  Note: As this point we are not accepting contributions. Please fork the
  repository if you want to extend the libraries for your use case.


pkgId: e27ab11d5eab8942583222d70b10dd9ae63641425dc4c559357ea65d2c8e8e3a
name: python-clubear
arch: src
version: 0.0.37
epoch: 0
release: 1
summary: Subsample-based Model and Research Toolkit.
url: https://pypi.org/project/clubear/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clubear-0.0.37-1.src.rpm
checksum_type: sha256
description:
  Clubear is a Python-based (Python 3) open-source package for interactive massive data analysis. The key feature of clubear is that it enables users to conduct convenient and interactive statistical analysis of massive data with only a traditional single-computer system. Thus, clubear provides a cost-effective solution when mining large-scale datasets. In addition, the clubear package integrates many commonly used statistical and graphical tools, which are useful for most commonly encountered data analysis tasks.

  Every component (class) within clubear have a 'demo()' function. Demo is used to demonstrate typical examples about this class. Users can use 'demo()' to quickly get instructions. For example, if we have an object 'sf':
  ```
  sf=cb.shuffle('airline.csv')
  ```
  we can get the instructions related to it by:
  ```
  sf.demon()
  ```
  Then, a typical case will be printed for reference.




  ```
  pip install clubear
  ```



  We recommend to use clubear with Jupyter Notebook. This will lead to the best user experience.
  ```
  import clubear as cb
  ```



  For example, shuffle a CSV file 'airline.csv'. The resulting file is 'airline.csv.shuffle'.
  ```
  sf=cb.shuffle('airline.csv')
  sf.dc()
  ```



  Build a bridge between the dataset and the memory (of a computer) using a 'pump'.
  Clubear supports various types of data sources to initialize the pump:

  (1). CSV file
  ```
  mypathfile='airline.csv.shuffle'
  pm=cb.pump(type=1, pathfile=mypathfile)
  ```

  (2). CSV file with a codebook (a dictionary contains specifications for variables)
  ```
  mycodebook = {
  'qlist': ['ActualElapsedTime', 'ArrDelay', 'ArrTime', 'CRSArrTime', 'CRSDepTime', 'CRSElapsedTime',
      'Cancelled', 'DayOfWeek', 'DayofMonth', 'DepDelay', 'DepTime', 'Distance', 'Diverted',
      'FlightNum', 'Month', 'Year', '_INTERCEPT_'], # specify quantitative variables
  'drop': ['TailNum', 'Origin', 'Dest'], # specify variables that can be removed
  'scale_level': {'UniqueCarrier': ['EV', 'OO', '9E']} # for any qualitative variable, users can further specify the scale levels
  }
  mypathfile='2008.csv.shuffle'
  pm=cb.pump(type=2, pathfile=mypathfile, codebook=mycodebook)
  ```

  (3). SQL databases
  ```
  mysql_info = {
  'host':'localhost', # SQL Server host
  'user':'root', # SQL Server username
  'passwd':'root', # SQL Server password
  'port':3306, # SQL Server port
  'db':'test_db', # name of database
  'tablename':'flight_2008' # name of table
  }
  pm=cb.pump(type=3, sql_info=mysql_info)
  ```

  Then, based on the pump, one can quickly access a part of the dataset as:
  ```
  pm.subsize=10000
  pm.go()
  ```

  Or view the most frequently used descriptive statistics as:
  ```
  ck=cb.check(pm).stats()
  ```



  Extract variables whose 'mp' values are less than 5%:
  ```
  ck[ck.mp<5].index
  ```

  Pass this list to 'pm' by the 'qlist' parameter:
  ```
  pm.qlist=[...]
  ```



  Detect all levels by the 'table' function as:
  ```
  tb=cb.check(pm).table(niter=100)
  ```

  Detect all levels for a specified variable, e.g., 'AirTime':
  ```
  tb=cb.check(pm).table('AirTime',tv=True)
  ```



  Clubear provides a number of graphical tools. For example, boxplot:
  ```
  tk = cb.tank(pm)
  pt=cb.plot(tk).box(x="Year",y="ArrDelay")
  ```

  Histogram:
  ```
  pt=cb.plot(tk).hist('Distance')
  ```

  Barplot:
  ```
  pt=cb.plot(tk).mu('ArrDelay','CRSDepTime')
  ```


pkgId: 691e7a5ee055c5aba120d15b73e763f8b39c4d651f89112e668c3bdca2d6b0c7
name: python-clubhouse
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Client for the Clubhouse API
url: https://github.com/j-martin/clubhouse-client
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clubhouse-0.3.0-1.src.rpm
checksum_type: sha256
description:
  Python client for Clubhouse



  The package is available on [pypi](https://pypi.org/project/clubhouse/) and can
  be installed like any other packages.

      $ pip install clubhouse



  Refer to [Clubhouse API Docs](https://clubhouse.io/api/rest/v2/) for more information.

  ```python
  from clubhouse import ClubhouseClient

  clubhouse = ClubhouseClient('your api key')

  story = {'name': 'A new story', 'description': 'Do something!'}
  clubhouse.post('stories', json=story)
  ```


pkgId: f58ad2c6104007b4f8d86d67be09f0ce4136f27ccde3a41d3a8188c27e96ac61
name: python-cluedin
arch: src
version: 2.5.0
epoch: 0
release: 1
summary: A Python client for CluedIn API.
url: https://github.com/romaklimenko/cluedin
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cluedin-2.5.0-1.src.rpm
checksum_type: sha256
description:
  [cluedin](https://pypi.org/project/cluedin/) is a Python client for [CluedIn](https://www.cluedin.com/) API.



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

  ```shell
  pip install cluedin
  ```





  Create a JSON file with context configuration to your CluedIn instance:

  In this file, parameters have the following meaning:

  - `protocol` - `http` if your CluedIn instance is not secured with a TLS certicate. Otherwise, `https` by default.
  - `domain` – CluedIn instance domain without the Organization prefix.
  - `org_name` – the name of Organization (a.k.a. Organization prefix).
  - `user_email` – the user's email.
  - `user_password` – the user's password.
  - `verify_tls` – `false`, if an unknown CA signs the TLS certificate. Otherwise, `true` by default.

  Here is an example of a file for a CluedIn instance running locally from a [Home](https://cluedin-io.github.io/Home/) repository:

  ```json
  {
    "protocol": "http",
    "domain": "127.0.0.1.nip.io",
    "org_name": "foobar",
    "user_email": "admin@foobar.com",
    "user_password": "Foobar23!"
  }
  ```

  We add the protocol, but we can skip this parameter if the URL starts with `https`. Likewise, we can skip `verify_tls` because it only makes sense for HTTPs URLs.

  Alternatively, to provide email and password, you can obtain an API access token from CluedIn UI and provide it in the file:

  ```json
  {
    "protocol": "http",
    "domain": "127.0.0.1.nip.io",
    "org_name": "foobar",
    "access_token": "..."
  }
  ```

  When the configuration file exists, you can export its path to an environment variable:

  ```shell
  export CLUEDIN_CONTEXT=~/.cluedin/home.json
  ```

  Now, you can load this file from your Python code and get an access token (if not already provided):

  ```python
  import cluedin

  context = Context.from_json_file(os.environ['CLUEDIN_CONTEXT'])
  context.get_token()
  ```

  You could also do it without the context file:

  ```python
  context = {
      "protocol": "http",
      "domain": "127.0.0.1.nip.io",
      "org_name": "foobar",
      "user_email": "admin@foobar.com",
      "user_password": "Foobar23!"
  }

  context = Context.from_dict(context)
  context.get_token()
  ```



  Get entities:

  ```python
  context = Context.from_json_file(os.environ['CLUEDIN_CONTEXT'])
  context.get_token()

  query = """
      query searchEntities($cursor: PagingCursor, $query: String, $pageSize: Int) {
        search(
          query: $query,
          sort: FIELDS,
          cursor: $cursor,
          pageSize: $pageSize
          sortFields: {field: "id", direction: ASCENDING}
        ) {
          totalResults
          cursor
          entries {
            id
            name
            entityType
          }
        }
      }
  """

  variables = {
      "query": "*",
      "pageSize": 10_000
  }



  entities = cluedin.gql.entries(context, query, variables):
  ```





  - `CLUEDIN_REQUEST_TIMEOUT_IN_SECONDS` - CluedIn API request timeout (in seconds). If not set, then it defaults to `300` (5 minutes).



  - `Context.from_dict(cls, context_dict: dict) -> Context` – creates a new `Context` object from a `dict`.
  - `Context.from_json_file(file_path: str) -> Context` – creates a new `Context` object from a JSON-file.



  - `cluedin.account.get_users(context: Context, org_id: str = None) -> list` – returns all users for Organization.
  - `cluedin.account.is_organization_available_response(context: Context, org_name: str) -> dict` – checks if a given Organization name is available. This method returns a JSON-response serialized into a `dict`.
  - `cluedin.account.is_organization_available(context: Context, org_name: str) -> bool` – checks if a given Organization name is available. Returns a Boolean.
  - `cluedin.account.is_user_available_response(context: Context, user_email: str, org_name: str) -> dict` – checks, if a user with a given email can be created or this email is already reserved. This method returns a JSON-response serialized into a `dict`.
  - `cluedin.account.is_user_available(context: Context, user_email: str, org_name: str) -> bool` – checks, if a user with a given email can be created or this email is already reserved. This method returns a JSON-response serialized into a `dict`. Returns a Boolean.
  - `cluedin.account.get_invitation_code(context: Context, email: str) -> str` – returns an invitation code for a given email.
  - `cluedin.account.create_organization(context: Context, user_email: str, password: str, org_name: str, org_sub_domain: str = None, email_domain: str = None, allow_email_domain_signup: bool = True, new_account_access_key: str = None) -> dict` - creates a new Organization. This method returns a JSON-response serialized into a `dict`.
  - `cluedin.account.create_user(context: Context, user_email: str, user_password: str) -> requests.models.Response` – creates a new user. This method returns `requests.models.Response`.
  - `cluedin.account.create_admin_user(context: Context, user_email: str, user_password: str) -> requests.models.Response` – creates a new admin user. This method returns `requests.models.Response`.
  - `cluedin.account.get_user(context: Context, user_id: str = None) -> dict` – returns a user by ID. If `user_id` is nor provided, the current user is returned. This method returns a JSON-response serialized into a `dict`.



  - `cluedin.entity.get_entity_blob(context: Context, entity_id: str) -> str` – returns an entity blob by ID.
  - `cluedin.entity.get_entity_as_clue(context: Context, entity_id: str) -> str` – returns an entity as a clue by ID.



  - `cluedin.gql.gql(context: Context, query: str, variables: dict = None) -> dict` – sends a GraphQL request and returns a response.
  - `cluedin.gql.org_gql(context: Context, query: str, variables: dict = None) -> dict` – sends a GraphQL request to Organization endpoint and returns a response.
  - `cluedin.gql.entries(context: Context, query: str, variables: dict = None, flat=False) -> Generator` – returns entries from a GraphQL search query. If cursor is requested in the GraphQL query (see the example above and tests), then it proceeds to next pages to return all results. If `flat` is `True`, then it flattens the `properties` dictionary of each returned entity.
  - `def search(context: Context, search_query: str, page_size: int = 10_000) -> Generator` – returns entities by a search query. This method is a wrapper around `cluedin.gql.entries`.



  - `dump(file: str, obj: Any) -> None` – serialize obj as a JSON formatted stream to file.
  - `load(file: str) -> Any` – deserialize file to a Python object.



  - `cluedin.jwt.get_jwt_payload(jwt: str) -> dict` – parses a JWT (JSON Web Token, a.k.a. access token or API token), and returns its payload serialized into a `dict`.



  - `cluedin.public.post_clue(context: Context, clue: str, content_type: str = 'application/xml') -> str` – posts a clue in XML or JSON format. This method returns an operation result as a string.
  - `cluedin.public.restore_user_entities(context: Context) -> list` – if you accidentally deleted `/Infrastructure/User` entities, this method gets all users and restores entities for those who miss them.



  - `cluedin.rules.RuleScope` - an enumeration of rule scopes: `DATA_PART`, `ENTITY`, `SURVIVORSHIP`.
  - `cluedin.rules.get_rules(context: Context, scope=RuleScope.DATA_PART) -> dict` – returns all rules for a given scope. This method returns a JSON-response serialized into a `dict`.
  - `cluedin.rules.get_rule(context: Context, rule_id: str) -> dict` – returns a rule by ID. This method returns a JSON-response serialized into a `dict`.



  - `cluedin.rules.evaluator.default_get_property_name(field: str) -> str` – returns a default property name for a given field. Used to map CluedIn Rules fields to your fields.
  - `cluedin.rules.evaluator.default_get_value(field: str, obj: dict) -> Any` – returns a default value for a given field. Used to map CluedIn Rules fields to your fields.
  - `cluedin.rules.Evaluator` – a class to evaluate CluedIn Rules.
  - `cluedin.rules.Evaluator.evaluate(context: Context, rule: dict, obj: dict) -> bool` – evaluates a rule for an object. Returns a Boolean:

    - `get_matching_objects(self, objects) -> list` – returns a list of objects that match the rule.
    - `object_matches_rules(self, obj) -> bool` – returns `True` if an object matches the rule.
    - `explain(self) -> str` – returns an explanation of the rule (in pandas `DataFrame.query` terms).



  - `cluedin.rules.operators.default_get_operator(operator_id) -> Any` – returns a default operator for a given operator ID. Used to map CluedIn Rules operators to your operators.

  You can add custom operatiors (see `test_operators.py` for examples), but the following CluedIn Rules operators are supported out of the box:

  - `Is Not True`
  - `Is True`
  - `Begins With`
  - `Between`
  - `Contains`
  - `Ends With`
  - `Equals`
  - `Exists`
  - `Greater`
  - `Greater or Equal`
  - `In`
  - `Is False`
  - `Is Not Null`
  - `Is Null`
  - `Is True`
  - `Less`
  - `Less or Equal`
  - `Matches pattern`
  - `Not Begins With`
  - `Not Between`
  - `Not Contains`
  - `Not Ends With`
  - `Not Equal`
  - `Does Not Exist`
  - `Not In`
  - `Does not match pattern`



  - `cluedin.vocab.get_vocab_keys(context: Context) -> list` – gets all vocabulary keys.


pkgId: 102e737e4a5862288dd243b1d99dee09e620ad87aa853d937efd40e696533b69
name: python-cluedin-magic
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: IPython magic commands for CluedIn
url: https://github.com/romaklimenko/cluedin-magic
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cluedin-magic-0.1.2-1.src.rpm
checksum_type: sha256
description:
  This module provides IPython [magic](https://ipython.readthedocs.io/en/stable/interactive/python-ipython-diff.html#magics) commands for interacting with the CluedIn API.

  ```python

  %pip install cluedin-magic
  ```

  ```python

  %load_ext cluedin_magic
  ```

  ```python

  api_token = '<your_token_here>'
  ctx = %cluedin get-context --jwt %api_token
  ```

  ```python

  %cluedin search --context ctx --query +entityType:/Infrastructure/User
  ```

  ```python

  %cluedin search --context ctx --query +entityType:/Infrastructure/User --limit 10
  ```

  ```python

  %cluedin search --context ctx --query +entityType:/IMDb/Name -properties.imdb.name.deathYear:"\\\\N" --limit 10
  ```

  ```python

  pd = %cluedin search --context ctx --query +entityType:/IMDb/Name +properties.imdb.name.birthYear:1981
  ```


pkgId: 73685c0b46821d65f2d13c0162454ce72d49f44f6eaf544022354a2fcc7bdcdb
name: python-clump-python
arch: src
version: 0.3.3
epoch: 0
release: 1
url: https://github.com/vsangelidakis/CLUMP
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clump-python-0.3.3-1.src.rpm
checksum_type: sha256
summary:
  This Python library provides tools for creating and examining clumps using techniques: the Euclidean Distance Transform, Favier, and Ferellec-McDowell. It allows for the efficient generation of clumps and the extraction of their surfaces.

description:
  CLUMP is a collection of scripts to generate multi-sphere particles of overlapping or non-overlapping spheres, which approximate target
  geometries. Multi-spheres (a.k.a. clumps) are popular in numerical simulations using the Discrete Element Method (DEM), but these geometric
  object can find applications in a wider perspective, past numerical modelling. The motivation behind developing CLUMP stemmed from the need
  to compare different clump-generation techniques, both in terms of particle morphology and mechanical performance using the DEM. To this
  end, CLUMP offers two existing and well established clump-generation techniques and proposes a new one. The generated clumps can be
  exported in various formats, compatible with some of the most prominent DEM codes. Last, the surface of each generated clump can be extracted
  as a triangulated mesh and saved as an stl file, allowing for a full characterisation of particle morphology, using tools like SHAPE or 3D-printing of
  physical particle replicas. CLUMP was initially developed in MATLAB and has now been fully translated in Python. Both implementations will
  continue to be developed in parallel as the software evolves.



  CLUMP performs the following functions:

  - __GenerateClump__
    - Favier et al (1999)
    - Ferellec and McDowell (2010)
    - Euclidean 3D (2021) and Extended Euclidean 3D (proposed in this code)

  - __ExportClump__
    - YADE
    - MercuryDPM
    - LAMMPS
    - EDEM
    - PFC3D

  - __CharacteriseClump__
    - Surface extraction





  Running the following code in the terminal (for Linux and macOS) or in the Command Prompt (for Windows) will automatically set up the module along with its corresponding dependencies.

  ```bash
  pip install clump-python
  ```




  After the installation using ```pip install clump-python```, CLUMP can easily be imported as

  ```python
  import CLUMP
  ```

  This following examples demonstrate different approaches to generate clumps for the different target geometry. The variables below are documented within each function.

  ```python
  from CLUMP.examples import Example_Euclidean_3D
  ```

  ```python
  from CLUMP.examples import Example_Euclidean_3D_Extended
  ```

  ```python
  from CLUMP.examples import Example_Ferellec_McDowell
  ```

  ```python
  from CLUMP.examples import Example_Favier
  ```

  The following example demonstrates the surface extraction method.

  ```python
  from CLUMP.examples import Example_ExtractSurface
  ```



  Here is an example of generating a clump from an STL file using __Euclidean Distance Transform__ method.

  ```python
  from CLUMP import GenerateClump_Euclidean_3D

  inputGeom = "path_of_STL.stl"
  N = 21
  rMin = 0
  div = 102
  overlap = 0.6
  output = 'path_of_clump_output.txt'
  outputVTK = 'path_of_clump_vtk.vtk'
  visualise = True

  GenerateClump_Euclidean_3D(inputGeom, N, rMin, div, overlap, output=output, outputVTK=outputVTK, visualise=visualise)
  ```

  To run the __Extended Euclidean Transform__, one needs to specify the maximum sphere radius which will trigger the extended version. The example is as follows:

  ```python
  from CLUMP import GenerateClump_Euclidean_3D

  inputGeom = "path_of_STL.stl"
  N = 21
  rMin = 0
  div = 102
  overlap = 0.6
  output = 'path_of_clump_output.txt'
  outputVTK = 'path_of_clump_vtk.vtk'
  visualise = True
  rMax_ratio = 0.3 # Parameter to trigger the Extended Euclidean method

  GenerateClump_Euclidean_3D(inputGeom, N, rMin, div, overlap, output=output, outputVTK=outputVTK, visualise=visualise, rMax_ratio=rMax_ratio)
  ```

  Here is an example for the __Ferellec-McDowell__ clump generation method:

  ```python
  from CLUMP import GenerateClump_Ferellec_McDowell

  inputGeom = "path_of_STL.stl"
  dmin = 0.1
  rmin = 0.01
  rstep = 0.01
  pmax = 1.0
  seed = 5
  output = 'path_of_clump_output.txt'
  outputVTK = 'path_of_clump_vtk.vtk'
  visualise = True

  mesh,clump=GenerateClump_Ferellec_McDowell(inputGeom=inputGeom, dmin=dmin, rmin=rmin, rstep=rstep, pmax=pmax, seed=seed, output=output, outputVTK=outputVTK, visualise=visualise)
  ```

  To generate a clump using the __Favier__ method, you can use the following example:

  ```python
  from CLUMP import GenerateClump_Favier

  inputGeom = "path_of_STL.stl"
  N = 10
  chooseDistance = 'min'
  output = 'path_of_clump_output.txt'
  outputVTK = 'path_of_clump_vtk.vtk'
  visualise = True

  mesh,clump=GenerateClump_Favier(inputGeom=inputGeom, N=N, chooseDistance=chooseDistance, output=output, outputVTK=outputVTK, visualise=visualise)
  ```

  Consider a clump defined as follows:

  ```python
  import numpy as np

  clump = np.array([[1, 0, 0, 1.1],
                    [2, 1, 0, 1.1],
                    [3, 0, 0, 1.2],
                    [1, 0, 1, 1.2]])
  ```

  To extract the surface of the clump, you can use __ExtractSurface__ function as follows:

  ```python
  from CLUMP import ExtractSurface

  N_sphere = 200
  N_circle = 100
  visualise = True

  faces, vertices = ExtractSurface(clump, N_sphere, N_circle, visualise)
  ```

   

  If you enjoy using CLUMP, you are welcome to require the implementation of new clump-generation approaches and features or even better contribute and share your implementations. CLUMP was created to provide a comparison of different methods, by collecting them in one place and we share this tool hoping that members of the community will find it useful. So, feel free to expand the code, propose improvements and report issues.


pkgId: 17f068819e9de266f3e2bb54186e2fcc65e1581265a9b128359b1bbf3724bf47
name: python-cluster-colors
arch: src
version: 0.16.0
epoch: 0
release: 1
summary: Cluster rgb vectors with divisive kmedians
url: https://pypi.org/project/cluster-colors/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cluster-colors-0.16.0-1.src.rpm
checksum_type: sha256
description:
  Processing and clustering colors from images presents some challenges:

  * Even a small (800x600) image will have up to 480,000 colors.
  * Solutions like PIL's `Image.quantize`, on the other hand, make the colors sample *too* coarse.
  * Even after reducing color variety, you're still dealing with 480,000 color *instances*.
  * Solutions like `scikit-learn`'s `KMeans` handle some of these challenges, but are non-deterministic and not flexible in the ways that I'd like.





  Average similar colors. Specifically, this maps an 8-bit color space to an n-bit color space then averages colors in each bin. An argument, `nbits`, specifies the number of bits to use for each color channel. The default is 6, which reduces 17-million-ish possible colors to 300-thousand-ish possible colors. The downside is that the boundaries between n-bit bins are arbitrary. Heavy concentrations of near-identical colors will be split if a boundary passes through them.

  Pooling colors from an image path will write a cache to your temp directory.



  Reduce the number of colors by recursively splitting the color space along the longest axis. This is a median cut algorithm, but it's not constrained to x, y, or z axes. The longest axis is determined by the standard deviation of the colors in the cluster. I've made the cut just a little bit smarter than standard median cut, but this is essentially k-medoids without the re-distribution step, so it's more efficient, but not the best we can do. An argument, `num`, specifies the number of colors to reduce to. 512 is a good number, but if you're still missing some nuance, you can increase it.



  * Both are deterministic.
  * Both handle frequency, weight, transparency.
  * Both allow a user-defined proximity matrix, so you can use whatever delta function you like as long as `delta(a,a)` is 0 and `delta(a,b)` is never 0. Common choices are Euclidean, squared Euclidean, and delta-e.
  * Divisive uses a variation of median cut followed by a kmediods-like reassignment step to conversion.
  * Agglomerative uses *complete linkage*.
  * Divisive is more robust to outliers and will give more even-sized clusters.
  * Divisive child clusters will not necessarily contain (or only contain) the members of the parent.
  * Agglomerative is more likely to separate outliers.
  * Agglomerative is heirarchical.

  Divisive clustering is typically better for, "What are the five dominant colors in this image?"

  Agglomerative clustering is typically better for, "How many colors do I need to represent this image with no more than `delta==3` between any two cluster members?"



      pip install cluster_colors



  ~~~python
  from cluster_colors import get_image_clusters


  clusters = get_image_clusters(image_filename)
  clusters.split_to_n(5)
  exemplars = clusters.get_as_vectors()


  show_clusters(split_clusters, "open_file_to_see_clusters")
  ~~~


pkgId: f9ecaa2f7a2015d29e01a2fee3753390b46a9b2cb1e499a3924ce18bc9bc5c4f
name: python-cluster-depp-test
arch: src
version: 0.0.21
epoch: 0
release: 1
summary: DEPP: Deep Learning Enables Extending Species Trees using Single Genes
url: https://github.com/yueyujiang/DEPP
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cluster-depp-test-0.0.21-1.src.rpm
checksum_type: sha256
description:
  DEPP is a deep-learning-based tool for phylogenetic placement.Output of the tool is the distance matrix between the query sequences and the backbone sequences


pkgId: c1941d703bc9bb61bbcf65972b1d17c4d112bcb6fa7516f51b8a9ef5a3df3b2f
name: python-cluster_tools
arch: src
version: 0.15.6
epoch: 0
release: 1
summary: Utility library for easily distributing code execution on clusters
url: https://pypi.org/project/cluster_tools/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cluster_tools-0.15.6-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://img.shields.io/github/actions/workflow/status/scalableminds/webknossos-libs/.github/workflows/ci.yml?branch=master)](https://github.com/scalableminds/webknossos-libs/actions?query=workflow%3A%22CI%22)
  [![Code Style](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://docs.astral.sh/ruff/)


  This package provides python `Executor` classes for distributing tasks on a Slurm cluster, Kubernetes, Dask or via multi processing.



  ```python
  import cluster_tools

  def square(n):
    return n * n

  if __name__ == '__main__':
    strategy = "slurm"  # other valid values are "multiprocessing" and "sequential"
    with cluster_tools.get_executor(strategy) as executor:
      result = list(executor.map(square, [2, 3, 4]))
      assert result == [4, 9, 16]
  ```


  The `cluster_tools` package requires at least Python 3.9.

  You can install it from [pypi](https://pypi.org/project/cluster_tools/), e.g. via pip:

  ```bash
  pip install cluster_tools
  ```

  By default only the dependencies for running jobs on Slurm and via multiprocessing are installed.
  For Kubernetes and Dask run:

  ```bash
  pip install cluster_tools[kubernetes]
  pip install cluster_tools[dask]
  ```





  The `cluster_tools` automatically determine the slurm limit for maximum array job size and split up larger job batches into multiple smaller batches.
  Also, the slurm limit for the maximum number of jobs which are allowed to be submitted by a user at the same time is honored by looking up the number of currently submitted jobs and only submitting new batches if they fit within the limit.

  If you would like to configure these limits independently, you can do so by setting the `SLURM_MAX_ARRAY_SIZE` and `SLURM_MAX_SUBMIT_JOBS` environment variables. You can also limit the maximum number of simultaneously running tasks within the slurm array job(s) by using the `SLURM_MAX_RUNNING_SIZE` environment variable.





  | Key                 | Description                                                                                                                                                                                                                                                              | Example                                 |
  | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------- |
  | `namespace`         | Kubernetes namespace for the resources to be created. Will be created if not existent.                                                                                                                                                                                   | `cluster-tools`                         |
  | `node_selector`     | Which nodes to utilize for the processing. Needs to be a [Kubernetes `nodeSelector` object](https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/).                                                                                                   | `{"kubernetes.io/hostname": "node001"}` |
  | `image`             | The docker image for the containerized jobs to run in. The image needs to have the same version of `cluster_tools` and the code to run installed and in the `PYTHONPATH`.                                                                                                | `scalableminds/voxelytics:latest`       |
  | `mounts`            | Additional mounts for the containerized jobs. The current working directory and the `.cfut` directory are automatically mounted.                                                                                                                                         | `["/srv", "/data"]`                     |
  | `cpu`               | [CPU requirements](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) for this job.                                                                                                                                                         | `4`                                     |
  | `memory`            | [Memory requirements](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) for this job. Not required, but highly recommended to avoid congestion. Without resource requirements, all jobs will be run in parallel and RAM will run out soon. | `16G`                                   |
  | `python_executable` | The python executable may differ in the docker image from the one in the current environment. For images based of `FROM python`, it should be `python`. Defaults to `python`.                                                                                            | `python3.8`                             |
  | `umask`             | `umask` for the jobs.                                                                                                                                                                                                                                                    | `0002`                                  |



  - The jobs are run with the current `uid:gid`.
  - The jobs are removed 7 days after completion (successful or not).
  - The logs are stored in the `.cfut` directory. This is actually redundant, because Kubernetes also stores them.
  - Pods are not restarted upon error.
  - Requires Kubernetes ≥ 1.23.
  - [Kubernetes cluster configuration](https://kubernetes.io/docs/concepts/configuration/organize-cluster-access-kubeconfig/) is expected to be the same as for `kubectl`, i.e. in `~/.kube/config` or similar.



  ```

  cd dockered-slurm
  docker compose up -d
  docker exec -it slurmctld bash
  docker exec -it c1 bash
  ```

  Make sure to install all extra dependencies, such as Kubernetes, with `uv sync --all-extras`.

  Tests can be executed with `cd tests && uv run pytest -s tests.py` after entering the container.
  Linting can be run with `./lint.sh`.
  Code formatting (black) can be run with `./format.sh`.



  Thanks to [sampsyo/clusterfutures](https://github.com/sampsyo/clusterfutures) for providing the slurm core abstraction and [giovtorres/slurm-docker-cluster](https://github.com/giovtorres/slurm-docker-cluster) for providing the slurm docker environment which we use for CI based testing.


pkgId: 1a8cff5c27ff0184c0bbe053fbe9890456b58b6ea26087523b08a9115309e4d6
name: python-clusterenv
arch: src
version: 0.3.29
epoch: 0
release: 1
url: https://pypi.org/project/clusterenv/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clusterenv-0.3.29-1.src.rpm
checksum_type: sha256
summary:
  ClusterEnv is a Python Gym environment designed to simulate and model the management and optimization of computing clusters. In the realm of distributed computing.

description:
  ClusterEnv is a Python Gym environment designed to simulate and model the management and optimization of computing clusters. In the realm of distributed computing


pkgId: 9be1ae6ab3ce0fc243946486d635e47d7b580ac5cc9ecce63893feb40948dade
name: python-clusterfudge
arch: src
version: 0.44.0
epoch: 0
release: 1
summary: Clusterfudge is a supercomputer scheduler
url: https://clusterfudge.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clusterfudge-0.44.0-1.src.rpm
checksum_type: sha256
description:
  Clusterfudge's Python client for launching workloads, and integrated CLI.



  See the [Clusterfudge platform docs](https://docs.clusterfudge.com)

  Python library documentation coming soon...



      Python: >= 3.10



  Clusterfudge is available via pypi using your preferred package management tool.

  `pip install clusterfudge`


pkgId: 47e98af41f1bf0177683f802439c69356ad2bb8dba9622d8d7c80ff3fbc5b3fa
name: python-clusterfun
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Clusterfun - a plotting library to inspect data
url: https://pypi.org/project/clusterfun/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clusterfun-0.6.1-1.src.rpm
checksum_type: sha256
description:
  ![example workflow](https://github.com/gietema/clusterfun/actions/workflows/tests.yml/badge.svg)



  [Clusterfun](https://clusterfun.app) is a python plotting library to explore image and audio data. Play around with a live demo on [https://clusterfun.app](https://clusterfun.app).

  - [Getting started](#getting-started)
  - [A simple example](#a-simple-example)
  - [Main features](#main-features)
  - [Default parameters](#default-parameters)
  - [Plot types](#plot-types)
    - [Bar chart](#bar-chart)
    - [Confusion matrix](#confusion-matrix)
    - [Grid](#grid)
    - [Histogram](#histogram)
    - [Pie chart](#pie-chart)
    - [Scatterplot](#scatterplot)
    - [Violin plot](#violin-plot)
  - [Data loading](#data-loading)



  Clusterfun can be installed with pip:

  `pip install clusterfun`

  Clusterfun requires Python 3.8 or higher.

  Plots accept data in the form of a pandas DataFrame, which will be installed automatically if not already present.
  No account, payment, or internet connection is required to use clusterfun. Clusterfun is open source and free to use.



  ```python
  import pandas as pd
  import clusterfun as clt

  df = pd.read_csv("https://raw.githubusercontent.com/gietema/clusterfun-data/main/wiki-art.csv")
  clt.scatter(df, x="x", y="y", media="img_path", color="painter")
  ```

  ![Example plot](data/scatter.png)
  Data can be hosted locally or on AWS S3.

  As you can see, a clusterfun plot takes as input a pandas dataframe and column names indicating which columns to use for the visualisation. In this way, it is similar to the seaborn or the plotly library. But in clusterfun, you can:

  - Click and drag to select data to visualise it in a grid
  - Hover over data points to see them on the right side of the page
  - Click on data points to view zoomed in versions of the image related to the data point

  This makes clusterfun ideal for quickly visualising image data, which can be useful in the context of building datasets, exploring edge cases and debugging model performance.





  The default parameters for the plot types are as follows:

  - `df: pd.DataFrame` (required)

    The dataframe used for the data to plot. Most other parameters are column names in this dataframe (e.g. media, color, etc.).

  - `media: str` (required)

    The column name of the media to display in the plot. See data loading for more information about the type of media that can be displayed.

  - `show: bool = True`

    Whether to show the plot or not. If show is set to True, clusterfun will start a local server to display the plot in a web browser. More specifically, we start a FastAPI server where we mount the webpage as a static file. The application itself does not require an internet connection. All data is loaded locally and does not leave your machine/browser.
    If show is set to False, clusterfun only saves the required data to serve the plot later on and return the path to where the data is stored. If you want to serve the plot yourself later on, you can run `clusterfun  {path - to - data}|{uuid}` in the command line to start a local server for the plot you are interested in.

  - `color: Optional[str] = None`

    If given, points will be colored based on the values in the given column. Powerful for visualising clusters or classes of data.

  - `title: Optional[str] = None`

    The title to use for the plot.

  - `bounding_box: Optional[str] = None`

    You can visualise bounding boxes on top of your images by with the `bounding_box` parameter. For this to work, you need to have a bounding box column in the dataframe used to plot the data. Each cell in the dataframe needs to contain a dictionary or a list of dictionaries with bounding box values: xmin, ymin, xmax, ymax, label (optional), color (optional). The keys of the expected dictionary are:

    - `xmin: float | int`
    - `ymin: float | int`
    - `xmax: float | int`
    - `ymax: float | int`
    - `label: Optional[str] = None`
    - `color: Optional[str] = None`

    If no color is provided, a default color scheme will be used. The color value can be a color name or hex value. The label will be displayed in the top left of the bounding box.
    Example:

    ```python
    single_bounding_box = {
      "xmin": 12,
      "ymin": 10,
      "xmax": 100,
      "ymax": 110,
      "color": "green",
      "label": "ground truth"
    }
    ```



  The following plot types are available:

  - Bar chart
  - Confusion matrix
  - Grid
  - Histogram
  - Pie chart
  - Scatterplot
  - Violin plot



  ```python
  def bar_chart(
      df: pd.DataFrame,
      x: str,
      media: str,
      color: Optional[str] = None,
      ...
  ) -> Path:
  ```



  - `df: pd.DataFrame`
    The dataframe with the data to plot
  - `x: str`
    The column name of the data for the bar chart. One bar per unique value will be plotted.
  - `media: str`
    The column name of the media to display
  - `color: Optional[str] = None`
    If added, the color will be used to create a stacked bar chart.



  ```python
  import pandas as pd
  import clusterfun as clt

  df = pd.read_csv("https://raw.githubusercontent.com/gietema/clusterfun-data/main/wiki-art.csv")
  clt.bar_chart(df, x="painter", media="img_path", color="style")
  ```

  ![Example bar](data/bar.png)



  ```python
  def confusion_matrix(
      df: pd.DataFrame,
      y_true: str,
      y_pred: str,
      media: str,
      ...
  ) -> Path:
  ```



  - `df: pd.DataFrame`

    The dataframe with the data to plot

  - `y_true: str`

    The ground truth label. Values can be integers or strings.

  - `y_pred: str`

    The column name of the predicted label. Values can be integers or strings.

  - `media: str`

    The column name of the media to display



  ```python
  import pandas as pd
  import clusterfun as clt

  df = pd.read_csv("https://raw.githubusercontent.com/gietema/clusterfun-data/main/cifar10.csv")
  clt.confusion_matrix(df, y_true="label", y_pred="pred", media="img_path")
  ```

  ![Example confusion matrix](data/confusion.png)



  ```python
  def grid(
      df: pd.DataFrame,
      media: str,
      ...
  ) -> Path:
  ```



  - `df: pd.DataFrame`

    The dataframe with the data to plot

  - `media: str`

    The column name of the media to display



  ```python
  import pandas as pd
  import clusterfun as clt

  df = pd.read_csv("https://raw.githubusercontent.com/gietema/clusterfun-data/main/wiki-art.csv")
  clt.grid(df, media="img_path")
  ```

  ![Example grid](data/grid.png)



  ```python
  def histogram(
      df: pd.DataFrame,
      x: str,
      media: str,
      bins: int = 20,
      ...
  ) -> Path:
  ```



  - `df: pd.DataFrame`

    The dataframe with the data to plot

  - `x: str`

    The column name of the data for the histogram

  - `media: str`

    The column name of the media to display

  - `bins: int = 20`

    The number of bins to use for the histogram



  ```python
  import pandas as pd
  import clusterfun as clt

  df = pd.read_csv("https://raw.githubusercontent.com/gietema/clusterfun-data/main/wiki-art.csv")
  clt.histogram(df, x="brightness", media="img_path")
  ```

  ![Example histogram](data/histogram.png)



  ```python
  def pie(
      df: pd.DataFrame,
      color: str,
  ) -> Path:
  ```



  - `df: pd.DataFrame`

    The dataframe with the data to plot

  - `color`

    Column for the pies of the pie chart



  ```python
  import pandas as pd
  import clusterfun as clt

  df = pd.read_csv("https://raw.githubusercontent.com/gietema/clusterfun-data/main/wiki-art.csv")
  clt.pie_chart(df, color="painter", media="img_path")
  ```

  ![Example pie](data/pie.png)



  ```def scatter(
      df: pd.DataFrame,
      x: str,
      y: str,
      ...
  ) -> Path:
  ```



  - `df: pd.DataFrame`

    The dataframe with the data to plot

  - `x: str`

    The column name of the data for the x-axis

  - `y: str`

    The column name of the data for the y-axis



  ```python
  import pandas as pd
  import clusterfun as clt

  df = pd.read_csv("https://raw.githubusercontent.com/gietema/clusterfun-data/main/wiki-art.csv")
  clt.scatter(df, x="x", y="y", media="img_path")
  ```

  ![Example scatter](data/scatter.png)



  ```python
  def violin(
      df: pd.DataFrame,
      y: str,
      ...
  ) -> Path:
  ```



  - `df: pd.DataFrame`

    The dataframe with the data to plot

  - `y: str`

    The column name of the data for the y-axis



  ```python
  import pandas as pd
  import clusterfun as clt

  df = pd.read_csv("https://raw.githubusercontent.com/gietema/clusterfun-data/main/wiki-art.csv")
  df = df[df.painter.isin(["Pablo Picasso", "Juan Gris", "Georges Braque", "Fernand Leger"])]
  clt.violin(df, y="brightness", media="img_path")
  ```

  ![Example violin](data/violin.png)



  Clusterfun supports AWS S3 and local data storage and loading.
  The dataframe column corresponding to the media value in the plot will be used to determine where to load the media from.

  ```python
  import clusterfun as clt

  df = pd.read_csv("https://raw.githubusercontent.com/gietema/clusterfun-data/main/wiki-art.csv")
  clt.grid(df, media="img_column")
  ```

  AWS S3 media should start with `s3://`.
  Make sure to set a `AWS_REGION` environment variable to the region where your data is stored.

  Support for Google Cloud Storage is coming soon.


pkgId: afe70fe5b03045c356fc9a72227987439d6bfd80cecea73e79fc56c591680202
name: python-clusterfuzz
arch: src
version: 2.6.0
epoch: 0
release: 1
summary: ClusterFuzz
url: https://github.com/google/clusterfuzz
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clusterfuzz-2.6.0-1.src.rpm
checksum_type: sha256
description:
  This directory contains the source of ClusterFuzz.


  Run `./build.sh` to build the pip package.

  For testing, use a fresh Python 3 virtualenv, and install the package by running
  `pip install dist/*.whl`.

  Then,

  ```bash
  $ cd tests
  $ python -m unittest
  ```


  Increment the version field in `setup.py`, then run `./build.sh` to build the
  pip package. TODO: Tie pip package version to ClusterFuzz version once it's
  stable.

  Per
  [https://packaging.python.org/tutorials/packaging-projects/#uploading-the-distribution-archives],
  to publish the pip package,

  ```bash
  $ python3 -m pip install --user --upgrade twine
  $ python3 -m twine upload dist/*
  ```


pkgId: 27603ac26cb7cb43ac3963edd858c4b8a1f9de891904ee2f7985248676b37918
name: python-clusterops
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: Paper - Pytorch
url: https://github.com/The-Swarm-Corporation/ClusterOps
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clusterops-0.0.8-1.src.rpm
checksum_type: sha256
description:
  - **CPU Execution**: Dynamically assign tasks to specific CPU cores.
  - **GPU Execution**: Execute tasks on specific GPUs or dynamically select the best available GPU based on memory usage.
  - **Fault Tolerance**: Built-in retry logic with exponential backoff for handling transient errors.
  - **Resource Monitoring**: Real-time CPU and GPU resource monitoring (e.g., free memory on GPUs).
  - **Logging**: Advanced logging configuration with customizable log levels (DEBUG, INFO, ERROR).


pkgId: c46918a2ce0631885f3a24eb68a95b3229bac34073acbe99f66328d2adebbb46
name: python-clusterservice
arch: src
version: 0.0.24
epoch: 0
release: 1
summary: ClusterService API
url: https://github.com/markmo/clusterservice
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clusterservice-0.0.24-1.src.rpm
checksum_type: sha256
description:
  Clusters comments given seed questions.

  This model uses TensorFlow and PyTorch.

  Supporting Bitbucket Pipelines and GitHub Actions for CI/CD-based model deployment.


pkgId: 01c3de0b212dd1174f5672d674c377fb4a8f6c73488ac64b753d7ae74a5fd845
name: python-clusteval
arch: src
version: 2.2.2
epoch: 0
release: 1
summary: clusteval is a python package for unsupervised cluster validation.
url: https://erdogant.github.io/clusteval
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clusteval-2.2.2-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://erdogant.github.io/clusteval">
    <img src="https://github.com/erdogant/clusteval/blob/master/docs/figs/logo_large_2.png" width="300" />
    </a>
  </p>

  [![Python](https://img.shields.io/pypi/pyversions/clusteval)](https://img.shields.io/pypi/pyversions/clusteval)
  [![PyPI Version](https://img.shields.io/pypi/v/clusteval)](https://pypi.org/project/clusteval/)
  [![License](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/erdogant/clusteval/blob/master/LICENSE)
  [![BuyMeCoffee](https://img.shields.io/badge/buymea-coffee-yellow.svg)](https://www.buymeacoffee.com/erdogant)
  [![Github Forks](https://img.shields.io/github/forks/erdogant/clusteval.svg)](https://github.com/erdogant/clusteval/network)
  [![GitHub Open Issues](https://img.shields.io/github/issues/erdogant/clusteval.svg)](https://github.com/erdogant/clusteval/issues)
  [![Project Status](http://www.repostatus.org/badges/latest/active.svg)](http://www.repostatus.org/#active)
  [![Downloads](https://pepy.tech/badge/clusteval/month)](https://pepy.tech/project/clusteval)
  [![Downloads](https://pepy.tech/badge/clusteval)](https://pepy.tech/project/clusteval)
  [![DOI](https://zenodo.org/badge/232915924.svg)](https://zenodo.org/badge/latestdoi/232915924)
  [![Sphinx](https://img.shields.io/badge/Sphinx-Docs-Green)](https://erdogant.github.io/clusteval/)
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://erdogant.github.io/clusteval/pages/html/Documentation.html#colab-notebook)
  <!---[![Coffee](https://img.shields.io/badge/coffee-black-grey.svg)](https://erdogant.github.io/donate/?currency=USD&amount=5)-->

  ``clusteval`` is a python package that is developed to evaluate detected clusters and return the cluster labels that have most optimal **clustering tendency**, **Number of clusters** and **clustering quality**. Multiple evaluation strategies are implemented for the evaluation; **silhouette**, **dbindex**, and **derivative**, and four clustering methods can be used: **agglomerative**, **kmeans**, **dbscan** and **hdbscan**.



  **⭐️ Star this repo if you like it ⭐️**
















  On the [documentation pages](https://erdogant.github.io/clusteval/) you can find detailed information about the working of the ``clusteval`` with many examples.






  ```bash
  conda create -n env_clusteval python=3.8
  conda activate clusteval
  ```


  ```bash
  pip install clusteval
  ```


  ```python
  from clusteval import clusteval
  ```

  <hr>


  A structured overview of all examples are now available on the [documentation pages](https://erdogant.github.io/clusteval/).

  <hr>


  * [Example: Cluster validation using Silhouette score](https://erdogant.github.io/clusteval/pages/html/Examples.html#cluster-evaluation)

  <p align="left">
    <a href="https://erdogant.github.io/clusteval/pages/html/Examples.html#cluster-evaluation">
    <img src="https://github.com/erdogant/clusteval/blob/master/docs/figs/fig1b_sil.png" width="600" />
    </a>
  </p>




  * [Example: Determine the optimal number of clusters](https://erdogant.github.io/clusteval/pages/html/Plots.html#plot)

  <p align="left">
    <a href="https://erdogant.github.io/clusteval/pages/html/Plots.html#plot">
    <img src="https://github.com/erdogant/clusteval/blob/master/docs/figs/fig1a_sil.png" width="600" />
    </a>
  </p>



  * [Example: Plot the dendrogram](https://erdogant.github.io/clusteval/pages/html/Plots.html#dendrogram)

  <p align="left">
    <a href="https://erdogant.github.io/clusteval/pages/html/Plots.html#dendrogram">
    <img src="https://github.com/erdogant/clusteval/blob/master/docs/figs/dendrogram.png" width="600" />
    </a>
  </p>



  * [Example: Cluster validation using davies-boulin index](https://erdogant.github.io/clusteval/pages/html/Examples.html#dbindex-method)

  <p align="left">
    <a href="https://erdogant.github.io/clusteval/pages/html/Examples.html#dbindex-method">
    <img src="https://github.com/erdogant/clusteval/blob/master/docs/figs/dendrogram.png" width="600" />
    </a>
  </p>



  * [Example: Cluster validation using davies-boulin index](https://erdogant.github.io/clusteval/pages/html/Examples.html#dbindex-method)

  <p align="left">
    <a href="https://erdogant.github.io/clusteval/pages/html/Examples.html#dbindex-method">
    <img src="https://github.com/erdogant/clusteval/blob/master/docs/figs/fig2_dbindex.png" width="600" />
    </a>
  </p>



  * [Example: Cluster validation using derivative evaluation method](https://erdogant.github.io/clusteval/pages/html/Examples.html#derivative-method)

  <p align="left">
    <a href="https://erdogant.github.io/clusteval/pages/html/Examples.html#derivative-method">
    <img src="https://github.com/erdogant/clusteval/blob/master/docs/figs/fig3_der.png" width="600" />
    </a>
  </p>




  * [Example: Cluster validation using dbscan](https://erdogant.github.io/clusteval/pages/html/Examples.html#dbscan)

  <p align="left">
    <a href="https://erdogant.github.io/clusteval/pages/html/Examples.html#dbscan">
    <img src="https://github.com/erdogant/clusteval/blob/master/docs/figs/fig5_dbscan.png" width="600" />
    </a>
  </p>



  * [Example: Cluster validation using hdbscan](https://erdogant.github.io/clusteval/pages/html/Examples.html#hdbscan)

  <p align="left">
    <a href="https://erdogant.github.io/clusteval/pages/html/Examples.html#hdbscan">
    <img src="https://github.com/erdogant/clusteval/blob/master/docs/figs/fig4a_hdbscan.png" width="600" />
    <img src="https://github.com/erdogant/clusteval/blob/master/docs/figs/fig4b_hdbscan.png" width="600" />
    </a>
  </p>







  Please cite clusteval in your publications if this is useful for your research (see right top for citation).


  * Use ARI when the ground truth clustering has large equal sized clusters
  * Usa AMI when the ground truth clustering is unbalanced and there exist small clusters
  * https://scikit-learn.org/stable/modules/generated/sklearn.metrics.adjusted_rand_score.html
  * https://scikit-learn.org/stable/auto_examples/cluster/plot_adjusted_for_chance_measures.html#sphx-glr-auto-examples-cluster-plot-adjusted-for-chance-measures-py
  * https://github.com/idealo/imagededup
  * https://towardsdatascience.com/how-to-cluster-images-based-on-visual-similarity-cd6e7209fe34
  * https://github.com/facebookresearch/deepcluster
  * https://towardsdatascience.com/pca-on-hyperspectral-data-99c9c5178385
  * https://machinelearningmastery.com/face-recognition-using-principal-component-analysis/


  * Erdogan Taskesen, github: [erdogant](https://github.com/erdogant)
  * Contributions are welcome.
  * If you wish to buy me a <a href="https://erdogant.github.io/donate/?currency=USD&amount=5">Coffee</a> for this work, it is very appreciated :)
  	Star it if you like it!


pkgId: 8b90ae4ef29eb30835e6241123dbc7680a829f3f6e2ba6058e73a8ffabf3a71c
name: python-clutchtimealerts
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Default template for PDM package
url: https://pypi.org/project/clutchtimealerts/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clutchtimealerts-0.1.2-1.src.rpm
checksum_type: sha256
description:
  [![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)

  A service that tracks ongoing NBA games and sends alerts when games enter "clutch time"—the last five minutes of the fourth quarter or overtime when the point difference is five points or fewer. The serivce monitors live game data and sends notifications via configured messaging platforms (such as GroupMe, Slack, etc.) to keep you informed of the most intense moments.


  - **Real-Time Clutch Detection**: Monitors live NBA game data and detects when games enter clutch time.
  - **Customizable Alerts**: Configure the service to send alerts on various platforms (GroupMe, Slack, etc.).
  - **Multiple Game Support**: Tracks multiple NBA games simultaneously to ensure you don't miss any clutch moments.



  We currently support the following notification types out of the box:

  - **GroupMe**
  - **Slack**
  - **Twilio** (SMS)

  On our road map we want to expand the supported notification types. If there's a type you want to see supported add an issue or submit a PR for review.



  There are two different supported installation types: Python and Docker.

  **Python**

  To install the python package, first clone the repository then use pip to install it.

  ```sh
  git clone git@github.com:bwalheim1205/clutchtimealerts.git
  cd clutchtimealerts
  pip install clutchtimealerts
  ```

  To install via docker, first clone the repository then build using the Dockerfile.

  **Docker**

  ```sh
  git clone git@github.com:bwalheim1205/clutchtimealerts.git
  docker build clutchtimealerts/ -t clutchtimealerts
  ```





  The alert system utilizes a yaml configuration file. YAML contains configuration
  options for SQLite database and alert method configurations. Here is an example
  of a configuration file

  **Example Configuration**

  ```yaml
  db_file_path: clutchtime.db
  db_table_name: clutchgames
  notifications:
    - type: GroupMe
      config:
        bot_id: "<group-bot-id>"
    - type: Slack
      config:
        channel: "#general"
        token: "<slack-api-token>"
  - type: Twilio
      config:
        account_sid: "<twilio-accout-sid>"
        auth_token: "<twilio-auth-token>"
        from: "+14155551212"
        to:
          - "+14155551212"
          - "+14155551212"
  ```



  **db_file_path** (__Optional__): Path to sqllite database to store game data. Defaults to clutchtime.db

  **db_table_name** (__Optional__):  SQLite table name to store data in. Default to clutchgames

  **notifications**: List of notification configs
  -  **type**: class name or common name of the alert type
  -  **config**: kwargs** for the alert classes




  Once you've generated a configuration file you can run alert service
  using one of the following commands

  **Python**

  ```sh
  python3 -m clutchtimealerts -f <path-to-config>
  ```

  **Docker**
  ```sh
  docker run -v <path-to-config>:/app/config.yml clutchtimealerts
  ```


pkgId: 2456bb867dec3a0931b1918d82aa58d091fe90fc32c871f90691bd3d7d56d17d
name: python-clutui
arch: src
version: 1.0.1.5600
epoch: 0
release: 1
summary: 一个现代化的PyQt5 UI框架
url: https://github.com/buaoyezz/PyQt-ClutUI
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clutui-1.0.1.5600-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <img src="assets/icons/logo.png" alt="ClutUI Logo" width="200"/>
  </p>

  <p align="center">
      <strong>一个基于PyQt5的现代化UI框架</strong>
  </p>

  <p align="center">
      <a href="#特性">特性</a> •
      <a href="#运行">运行</a> •
      <a href="#快速开始">快速开始</a> •
      <a href="#贡献">贡献</a> •
      <a href="#许可证">许可证</a> •
      <a href="#END">结语</a>
  </p>



  - 🎨 现代化设计风格
  - 🚀 丰富的预置组件
  - 📦 易于集成和使用
  - 🛠 高度可定制
  - 💡 智能的通知系统
  - 🎯 无边框窗口支持
  - 🌈 动画效果支持
    - 窗口最大化/还原动画
    - 侧边栏展开/收缩动画
    - 页面切换滑动动画
    - 通知弹出/消失动画
  - 🎭 丰富的组件库
    - ClutButton - 现代化按钮组件
      ```python
      
      from assets.utils.clut_button import ClutButton

      
      button = ClutButton("点击我")
      
      primary_button = ClutButton("主要按钮", primary=True)
      ```
    - ClutCard - 卡片容器组件
      ```python
      from assets.utils.clut_card import ClutCard

      
      card = ClutCard()
      card.set_title("卡片标题")
      card.set_content("这是卡片内容")
      ```
    - ClutImageCard - 图片卡片组件
      ```python
      from assets.utils.clut_image_card import ClutImageCard

      
      image_card = ClutImageCard("图片路径", "卡片标题", "卡片描述")
      ```
    - ClutLineEdit - 输入框组件
      ```python
      from assets.utils.clut_button import ClutLineEdit

      
      input_box = ClutLineEdit()
      input_box.setPlaceholderText("请输入内容...")
      ```
    - ClutMessageBox - 消息对话框组件
      ```python
      from assets.utils.message_box import ClutMessageBox

      
      msg_box = ClutMessageBox(title="提示", text="这是一条消息", buttons=["确定", "取消"])
      result = msg_box.exec_()
      ```
    - OverlayNotification - 通知提示组件
      ```python
      from assets.utils.notification import OverlayNotification

      
      notification = OverlayNotification()
      
      notification.show_message("这是一条通知消息")
      ```
    - Clut_Bar - 自定义标题栏组件
      ```python
      from assets.utils.titlebar import Clut_Bar

      
      title_bar = Clut_Bar()
      
      title_bar.title.setText("我的应用")
      ```



  1. 克隆仓库:
     ```bash
     git clone https://github.com/buaoyezz/PyQt-ClutUI.git
     ```

  2. 安装依赖:
     ```bash
     pip install PyQt5
     ```

  3. 运行示例:
      直接运行ClutUI_Main.py
      或
      ```bash
      python ClutUI_Main.py
      ```



  1. 导入需要的组件
  2. 创建组件实例
  3. 设置组件属性
  4. 将组件添加到布局中



  -欢迎提交 Issue 和 Pull Request!



  - 本项目采用 GPL-3.0 许可证
  - 更多信息请参阅 LICENSE 文件



  - 感谢您的使用和支持！
  - 本框架仍在开发中，欢迎提出建议和贡献！
  - 喜欢的话请给个Star吧！
  - 代码写的不好，见谅


pkgId: 8a9923ae334bfd307e24266e28d803c7dc6b0fd4eccd026056dd08d5725eee61
name: python-clx-sdk-xms
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Library for CLX Communications HTTP REST Messaging API
url: https://github.com/clxcommunications/sdk-xms-python
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clx-sdk-xms-1.0.0-1.src.rpm
checksum_type: sha256
description:
  This is the Python SDK for the CLX Communications REST API (also
  called XMS) for sending and receiving single or batch SMS messages. It
  also supports scheduled sends, organizing your frequent recipients
  into groups, and customizing your message for each recipient using
  parametrization.
  This library is compatible with Python 2.7 and 3.3 and later.


pkgId: 9815fd644d59e3aa65ccd45da29e9c4778b37e8726fb4f6ddeea1351685bfd70
name: python-cly-why
arch: src
version: 0.3.12
epoch: 0
release: 1
summary: A super simple functional cli helper lib
url: https://pypi.org/project/cly-why/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cly-why-0.3.12-1.src.rpm
checksum_type: sha256
description:
  I wanted a simple library to write small to moderate cli programs.
  It only uses the standard library.



  Its way more then what I need 99% of the time.


  I don't particularly like decorators.


  I like pprint, but it always seems like to much


  I've used typer a bit, but it never clicked with me.



  Take a string and color/text-decoration name and returns the string wrapped in its ansi code

  Entrypoint function
  By default ignores functions that start with '_'/underscore


  - [X] Colorize and Text Decorate
  - [ ] Tests
  - [ ] Automatic Fish Shell Completions
  - [ ] Prompts
    - [ ] Text Prompt
    - [ ] Multiline Prompt
    - [ ] Fzf Selector
    - [ ] Date Selector
  - [ ] 2 line functionality
  ```python
  import cly_why

  if __name__ == "__main__":
  	cly_why.cly()
  ```


pkgId: 13751d2bd8bec9f0b09dd6bcd8fe0925b7af6043ff87f0cd5053696b6077295e
name: python-clyjin
arch: src
version: 0.2.12
epoch: 0
release: 1
summary: Core for building plugins with CLI interfaces
url: https://github.com/ryzhovalex/clyjin
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clyjin-0.2.12-1.src.rpm
checksum_type: sha256
description:
  Provides a core for building plugins with CLI interfaces.



  If you want to install some plugin, you probably need only one command:
  ```sh
  pip install clyjin_someplugin
  ```

  Additional steps might be required, consult with plugin's documentation for
  details.

  If you want to install Clyjin Core to develop own plugin, you might want to
  start with:
  ```sh
  pip install clyjin
  ```

  Or, using [poetry](https://python-poetry.org/):
  ```sh
  poetry add clyjin
  ```



  To get grasp of Clyjin's functionality we'll develop a new plugin called
  `Hello`.

  First, you need to create a new Python project which name starts with
  `clyjin_`, e.g. `clyjin_hello`.

  Structure of the project might look like:
  ```
  .
  ├── .venv
  ├── clyjin_hello/
  │   ├── __init__.py
  │   └── _main.py
  ├── poetry.lock
  └── pyproject.toml
  ```

  Main class of your plugin-project is `Plugin`. Clyjin on initialization makes
  imports of your defined plugin with statement like
  `from clyjin_hello import MainPlugin`.

  This means you need to define a variable called `MainPlugin` in your
  `__init__.py` pointing to your plugin class:
  ```python

  from clyjin_hello._main import HelloPlugin

  MainPlugin = HelloPlugin
  ```

  That said, our plugin can be defined wherever we want, but we should reference
  it to be importable from our root Python package via name `MainPlugin`.

  The plugin itself in our example is defined within `_main.py`:
  ```python

  from clyjin.base import Plugin, PluginInitializeData

  class HelloPlugin(Plugin):
      Name = "hello"
      ModuleClasses = [
          RootModule,
          GreetingsModule
      ]
      
      Version = importlib.metadata.version("clyjin_hello")

      @classmethod
      async def initialize(
          clas,
          data: PluginInitializeData
      ) -> None:
          
          ...
  ```

  Let's do a quick overview of the things happened here:
  - `Name = "hello"` - defines a callable name for our plugin. It will be used
      as a main entrypoint in CLI and in other references.
  - `ModuleClasses = [...]` - list of module classes defined for your plugin.
  - `Version = importlib.metadata.version("clyjin_hello")` - version of our
      plugin. In this case retrieved dynamically from package's data.
  - `async def initialize(...)` - extra initialization logic for our plugin.

  Our plugin's modules can be defined as follows:
  ```python
  from clyjin.base import Module, ModuleData

  class RootModule(Module[MyRootArgs, MyRootConfig]):
      Name = "$root"
      Description = "show count of hello words said"
      Args = MyRootArgs(
          output_dir=ModuleArg[str](
              names=["output_dir"],
              type=Path,
              help="where to write the result output"
          )
          is_world_only=ModuleArg[bool](
              names=["-w", "--world"],
              action="store_true",
              type=bool,
              argparse_type=type,
              help="whether should count only \"hello world\" messages"
          )
      )

      def __init__(
          self,
          module_data: ModuleData[MyRootArgs, MyRootConfig]
      ) -> None:
          super().__init__(module_data)

          
          
          
          

      async def execute(self) -> None:
          
          
          ...
  ```

  - `class RootModule(Module[MyRootArgs, MyRootConfig])` - declares our module's
      class, inheriting it from generic module with setting as first argument
      our Args class and as second argument our Config class.
  - `Name = "$root"` - special name for a module indicates that this module is a
      root module. Root modules are called directly under Plugin's namespace,
      e.g. `clyjin hello ...`, while other modules are called like
      `clyjin hello.module_name ...`.
  - `Description = "..."` - description of the module, appeared at least in CLI
      help output
  - `Args = MyRootArgs(...)` - initialization of our module's args class.
      Args class contains information about CLI arguments supported by our
      module. It's structure is mostly similar like arguments passed to
      argparse.add_argument.
  - `def __init__(...)` - initialization method of our module accepting
      ModuleData object as first argument. ModuleData contains information about
      args, config and some extra helper fields, such as `rootdir`. Insider our
      Module super class all these fields are set to protected instance's
      variables, like `self._rootdir` making them available for further usage.
  - `async def execute(self) -> None` - method called if Clyjin core decided to
      chose this module to execute next request. Typically, if you need to
      access CLI arguments passed within this method, you will need to use
      `this.args.your_cli_arg.value` statement.

  You can define as many modules as you need in your `Plugin.ModuleClasses`
  field, but you can have only one root module, i.e. module with name `$root`,
  and other module names should be all unique.

  To call your plugin anywhere, you need to install `clyjin` and `clyjin_hello`
  (i.e. your plugin) and issue a CLI command:
  ```sh
  clyjin <your_plugin_name>.<your_module_name> <...arguments>
  ```

  For example for our imaginary GreetingsModule, which is part of HelloPlugin,
  we might issue a command:
  ```sh
  clyjin clyjin_hello.greetings --to world --from $USER
  ```





  [in process of writing, take some coffee ☕]



  - [📑 Clyjin Templates](https://github.com/ryzhovalex/clyjin_templates)
  - [⚙️ Clyjin Make](https://github.com/ryzhovalex/clyjin_make)


pkgId: 0d7bff59e0305ee1282d029dd38ba0253dcbd41703661ce82ac28afe2a14092c
name: python-clyngor
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: Python wrapper around Clingo/Answer Set Programming
url: https://github.com/aluriak/clyngor
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clyngor-0.4.3-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="clyngor.png"/><br>
  </p>

  Handy python wrapper around [Potassco's Clingo](https://potassco.org/) [ASP solver](https://en.wikipedia.org/wiki/Answer%20set%20programming).




  Clyngor offers multiple interfaces. The followings are all equivalent.
  (they search for [formal concepts](https://en.wikipedia.org/wiki/Formal_concept_analysis))

  ```python
  from clyngor import ASP, solve

  answers = ASP("""
  rel(a,(c;d)). rel(b,(d;e)).
  obj(X):- rel(X,_) ; rel(X,Y): att(Y).
  att(Y):- rel(_,Y) ; rel(X,Y): obj(X).
  :- not obj(X):obj(X).
  :- not att(Y):att(Y).
  """)
  for answer in answers:
      print(answer)
  ```

  The same, but with the lower level function expecting files:

  ```python
  answers = solve(inline="""
  rel(a,(c;d)). rel(b,(d;e)).
  obj(X):- rel(X,_) ; rel(X,Y): att(Y).
  att(Y):- rel(_,Y) ; rel(X,Y): obj(X).
  :- not obj(X):obj(X).
  :- not att(Y):att(Y).
  """)
  ```

  More traditional interface, using file containing the ASP source code:

  ```python
  answers = solve('concepts.lp'):  # also accepts an iterable of file
  ```

  More examples are available in [the unit tests](clyngor/test/).




  Once you get your answers, clyngor allows you to specify
  the answer sets format using builtin methods:

  ```python
  for answer in answers.by_predicate.first_arg_only:
      print('{' + ','.join(answer['obj']) + '} × {' + ','.join(answer['att']) + '}')
  ```

  And if you need a [*pyasp-like*](https://github.com/sthiele/pyasp) interface:

  ```python
  for answer in answers.as_pyasp:
      print('{' + ','.join(a.args()[0] for a in answer if a.predicate == 'obj')
            + '} × {' + ','.join(a.args()[0] for a in answer if a.predicate == 'att') + '}')
  ```

  Currently, there is only one way to see all chaining operator available:
  [the source code of the Answers object](clyngor/answers.py).
  (or `help(clyngor.Answers)`)






  If the used version of clingo is compiled with python, you can put python code into your ASP code as usual.
  But if you also have the [clingo package](https://potassco.org/clingo/python-api/current/clingo.html)
  installed and importable, clyngor can use it for various tasks.

  Using the official API leads to the following changes :

  - both robust and quick parsing, instead of the simple vs slow method
  - some options are not supported : constants, [time-limit](clyngor/test/test_time_limit.py), parsing error handling, [decoupled grounding/solving](clyngor/test/test_grounding.py)

  You can activate the use of the clingo module by calling once `clyngor.activate_clingo_module()`
  or calling `clyngor.solve` with argument `use_clingo_module` set to `True`.



  For users putting some python in their ASP, clyngor may help.
  The only condition is to have clingo compiled with python support,
  and having clyngor installed for the python used by clingo.



  Clyngor provides `converted_types` function,
  allowing one to avoid boilerplate code based on type annotation when
  calling python from inside ASP code.

  Example (see [tests](clyngor/test/test_upapi.py) for more):

  ```python

  from clyngor.upapi import converted_types
  @converted_types
  def f(a:str, b:int):
      yield a * b
      yield len(a) * b


  p(X):- (X)=@f("hello",2).
  p(X):- (X)=@f(1,2).  % ignored, because types do not match
  ```

  Without `converted_types`, user have to ensure that `f` is a function returning a list,
  and that arguments are of the expected type.

  Note that the [incoming clingo version](https://github.com/potassco/clingo/issues/147)
  is leading to that flexibility regarding returned values.



  Propagators are presented in [this paper](http://drops.dagstuhl.de/opus/volltexte/2016/6733/). They are basically active
  observers of the solving process, able for instance to modify truth assignment
  and invalidate models.

  As shown in [clyngor/test/test_propagator_class.py](clyngor/test/test_propagator_class.py),
  a high-level propagator class built on top of the official API is available, useful in many typical use-cases.



  As shown in [examples/pyconstraint.lp](examples/pyconstraint.lp),
  clyngor also exposes some helpers for users wanting to create propagators
  that implement an ASP constraint, but written in Python:

  ```python

  from clyngor import Constraint, Variable as V, Main


  def formula(inputs) -> bool:
      return inputs['b', (2,)]

  constraint = Constraint(formula, {('b', (V,))})


  main = Main(propagators=constraint)



  % ASP part, computing 3 models, b(1), b(2) and b(3).
  1{b(1..3)}1.
  ```


  An idea coming from the [JSON decoders](https://docs.python.org/3/library/json.html#encoders-and-decoders), allowing user to specify how to decode/encode custom objects in JSON.
  With clyngor, you can do something alike for ASP (though very basic and only from ASP to Python):

  ```python
  import clyngor, itertools

  ASP_LIST_CONCEPTS = """  % one model contains all concepts
  concept(0).
  extent(0,(a;b)). intent(0,(c;d)).
  concept(1).
  extent(1,(b;e)). intent(1,(f;g)).
  concept(2).
  extent(2,b). intent(2,(c;d;f;g)).
  """

  class Concept:
      "Decoder of concepts in ASP output"
      def __init__(self, concept:1, extent:all, intent:all):
          self.id = int(concept[0])
          self.extent = frozenset(arg for nb, arg in extent if nb == self.id)
          self.intent = frozenset(arg for nb, arg in intent if nb == self.id)
      def __str__(self):
          return f"<{self.id}: {{{','.join(sorted(self.extent))}}} × {{{','.join(sorted(self.intent))}}}>"

  objects = clyngor.decode(inline=ASP_LIST_CONCEPTS, decoders=[Concept])
  print('\t'.join(map(str, objects)))
  ```

  This code will print something like:

      <2: {b} × {c,d,f,g}>	<0: {a,b} × {c,d}>	<1: {b,e} × {f,g}>

  Note the use of annotations to declare that each `concept` must be associated to one instance,
  and that all `extent` and `intent` must be sent to constructor for each object.

  See [tests](clyngor/test/test_decoder.py) for complete API example.

  Remaining features for a good decoder support:

  - encoding: try to more-or-less automatically build the python to ASP compiler
  - more available annotations, for instance `(3, 5)` (to ask for between 3 and 5 atoms to be associated with the instance), or `any` (exact meaning has to be found)
  - allow to raise an InvalidDecoder exception during decoder instanciation to get the instance discarded



  Clyngor is basically the total rewriting of [pyasp](https://github.com/sthiele/pyasp), which is now abandoned.

  For an ORM approach, give a try to [clorm](https://github.com/daveraja/clorm).





      pip install clyngor

  You must have [`clingo`](https://potassco.org/doc/start/) in your path. Depending on your OS, it might be done with a system installation,
  or through [downloading](https://github.com/potassco/clingo/releases) and (compilation and) manual installation.

  You may also want to install the [python clingo module](https://potassco.org/clingo/python-api/current/clingo.html),
  which is [an optional dependancy](#official-api-embedding).




  By default, clyngor uses a very simple parser (yeah, `str.split`) in order to achieve time efficiency in most time.
  However, when asked to compute a particular output format (like `parse_args`) or an explicitely *careful parsing*,
  clyngor will use a much more robust parser (made with an [arpeggio](http://www.igordejanovic.net/Arpeggio/) grammar).


  See the [`utils` module](clyngor/utils.py) and its [tests](clyngor/test/test_utils.py),
  which provides high level routines to save and load answer sets.




  ```python
  import clyngor
  clyngor.CLINGO_BIN_PATH = 'path/to/clingo'
  ```

  Note that it will be the very first parameter to [`subprocess.Popen`](https://docs.python.org/3/library/subprocess.html#popen-constructor).
  The `solve` function also support the `clingo_bin_path` parameter.

  The third solution is to use the decorator `with_clingo_bin`, which modify the global variable
  during the execution of a specific function:

  ```python
  import clyngor

  @clyngor.with_clingo_bin('clingo454')
  def sequence():
      ...
      clyngor.solve(...)  # will use clingo454, not clingo, unless clingo_bin_path is given
      ...
  ```



  The `solve` functions allow to pass explicitely some parameters to clingo
  (including number of models to yield, time-limit, and constants).
  Using the `options` parameter is just fine, but with the explicit parameters some verifications
  are made against data (mostly about type).

  Therefore, the two followings are equivalent ; but the first is more readable and will crash earlier with a better error message if `n` is not valid:

  ```python
  solve('file.lp', nb_model=n)
  solve('file.lp', options='-n ' + str(n))
  ```






  No.


  Yes.


  No, it's pronounced [*clyngor*](https://www.youtube.com/watch?v=RyU99BCNRuU#t=50s).


  Clyngor was designed to not require the official module, because it required a manual compilation and installation of clingo.
  However, because of the obvious interest in features and performances,
  the official module can be used by clyngor if it is available.



  - [timeout](https://stackoverflow.com/a/12698328/3077939) in addition to time-limit
  - ASP source code debugging generator (started in [clyngor-parser](clyngor-parser))




  - bioinformatics, to encode biological pathway logic in [pathmodel](https://github.com/pathmodel/pathmodel) and [Menetools](https://github.com/cfrioux/MeneTools), and for [community detection](https://github.com/cfrioux/miscoto).
  - mathematics, to encode some [FCA]()-related task such as [AOC-poset generation](https://github.com/Aluriak/AOC-poset-generation) or [concept search](https://github.com/Aluriak/concept-generation), and [graph compression](https://github.com/Aluriak/PowerGrASP) or [graph manipulation](https://github.com/Aluriak/phasme) in the context of graph theory.
  - visualization, with [Draco](https://github.com/uwdata/draco), a formalization of visualization design knowledge as constraints, and [biseau](https://gitlab.inria.fr/lbourneu/biseau), an ASP-to-graph compiler.
  - web applications, for [a sudoku solver made with ASP](https://github.com/llaisdy/phoenix_live_view_sudoku/).




  - 0.4.0 (todo)
      - see [further ideas](#Further-ideas)
  - 0.3.28
      - [706747045](https://github.com/aluriak/clyngor/commit/706747045cb96abcb9de1e2d729cd43c084cb36f): handle default negation on atoms, by keeping the prefixed dash
      - [d4830ad52](https://github.com/aluriak/clyngor/commit/d4830ad521a6dcf9024f2c70f2f50e6b19f8c7a2): fix an import error
  - 0.3.25
      - [80245b2a7](https://github.com/aluriak/clyngor/commit/80245b2a72b8d76639b44a2315622f6743a7bc17): remove f-strings for 3.4 and 3.5 compat.
      - [6efdb6ab0](https://github.com/aluriak/clyngor/commit/6efdb6ab0f0304b28b35d6ceb16545226b2f9e3e): fix combination of .as_pyasp and .parse_args, where atoms in args were not transformed as pyasp Atom objects.
      - [fe4107573](https://github.com/aluriak/clyngor/commit/fe410757386e2c3e0881ecc90d7f18ee97672194): correctly parse atoms starting with underscores.
      - [d6507f17d](https://github.com/aluriak/clyngor/commit/d6507f17dbf27c6c309e3e4009a234b9d63134ba): careful parsing is automatically set when answer set [obviously needs it](clyngor/parsing.py#L266).
      - [f2c65e8ae](https://github.com/aluriak/clyngor/commit/f2c65e8ae018b9d3589a058a09f9de87e1f3fdf3): fixed bug when using clingo module and `.int_not_parsed`.
  - 0.3.24
      - [f92248e91](https://github.com/aluriak/clyngor/commit/f92248e91def2c979fd2f8f8af3755b86485becf): `#show 3.` and `#show "hello !".` are now handled
      - [31375774c](https://github.com/aluriak/clyngor/commit/31375774c437403e8a05f5fe8d0346caba0f43e4): when using clingo module, the models contains only the output atoms, not everything (thank you Arnaud)
      - [cc6021797](https://github.com/aluriak/clyngor/commit/cc60217975de123a5ef0d083fb10971e0d89c03e): support for `.with_answer_number`, giving model, optimization, optimality and answer number
      - [c0c090c34](https://github.com/aluriak/clyngor/commit/c0c090c34a7028ba34c49815f0197c67c76e7bfb): parsing and string reproduction of nested atoms such as `a((a("g(2,3)",(2)),))` is now correctly handled and tested
      - [1840c36e3](https://github.com/aluriak/clyngor/commit/1840c36e3f57c926a565fef7352cd1b083194e58): fix the `models.command` output when clingo module is used
      - [2679d26a9](https://github.com/aluriak/clyngor/commit/2679d26a91720ab507fb7c2ffc41c064e8ca9cb9): optimize memory usage of `opt_models_from_clyngor_answers` by using yield and answer number, but is now a generator and loses (the useless) `repeated_optimal` option
  - 0.3.20
      - fix [#7](https://github.com/Aluriak/clyngor/issues/7)
      - improve testing cover, fix warning in recent versions of pytest
      - more robust options parsing when solving with clingo module
  - 0.3.19
      - fix [#16](https://github.com/Aluriak/clyngor/issues/16)
  - 0.3.18
      - TermSet bugfix
      - `TermSet.add` to add atoms to the TermSet
      - `TermSet.union` to generate the union of multiple TermSet instances
  - 0.3.17
      - support for decoupled grounding and solving, as shown in [dedicated example](examples/decoupled-grounding.py)
      - new parameter `return_raw_output` for clyngor.solve, allowing to get stdout/stderr without treatments
      - [new example](examples/enum-optN.py) showing how to retrieve all optimal models using clyngor, and…
      - … the defined function `opt_models_from_clyngor_answers` is now embedded in clyngor API
  - 0.3.16
      - support for `.by_arity`, equivalent to `.by_predicate` but with predicate and arity
      - decorator `with_clingo_bin`, changing clingo binary path for encapsulated function
      - support for `.with_optimality`, giving optimization and optimality along with the model
  - 0.3.14
      - decoders support, see [`clyngor.decoder`](clyngor/decoder.py) and [doc](#decoders)
  - 0.3.10
      - support for `.discard_quotes` option (thanks to ArnaudBelcour)
      - bugfix: `.atom_as_string` and `.first_arg_only` collision
      - bugfix: more robust tempfile deletion and closing management
      - [demonstration](examples/pyconstraint-is-not-working.lp) of the non-working Constraint type implementation
  - before
      - predicat to know if python/lua are available with used clingo binary
      - easy interface for most use cases using type hint for embedded python
      - easy python constraints in ASP with Constraint type
      - add support for propagators
      - add support for clingo official python module



  If you have a project that makes use of pyasp, but need clingo instead of gringo+clasp, one way to go is to use clyngor instead.

  Here was my old code:

  ```python
  from pyasp import asp

  def solving(comp, graph):
      programs = [comp, graph]
      clasp_options = ['--opt-mode=optN', '--parallel-mode=4', '--project']
      solver = asp.Gringo4Clasp(clasp_options=clasp_options)
      print("solver run as: `clingo {} {}`".format(' '.join(programs), clasp_options))
      at_least_one_solution = False
      for answerset in solver.run(programs, collapseAtoms=False):
          yield answerset

  def find_direct_inclusions(model) -> dict:
      programs = [ASP_SRC_INCLUSION]
      solver = asp.Gringo4Clasp()
      add_atoms = ''.join(str(atom) + '.' for atom in model)
      answers = tuple(solver.run(programs, collapseAtoms=False,
                                 additionalProgramText=add_atoms))
      return answers
  ```

  And here is the version using clyngor, that pass the exact same unit tests:

  ```python
  import clyngor

  def solving(comp, graph):
      programs = [comp, graph]
      clasp_options = '--opt-mode=optN', '--parallel-mode=4', '--project'
      answers = clyngor.solve(programs, options=clasp_options)
      print("solver run as: `{}`".format(answers.command))
      for answerset in answers.as_pyasp.parse_args.int_not_parsed:
          yield answerset

  def find_direct_inclusions(model) -> dict:
      programs = [ASP_SRC_INCLUSION]
      add_atoms = ''.join(str(atom) + '.' for atom in model)
      answers = tuple(clyngor.solve(programs, inline=add_atoms).as_pyasp.parse_args)
      return answers
  ```



  To [Arnaud Belcour](https://github.com/ArnaudBelcour) for his works and frequent feedbacks.

  To [Domoritz](https://github.com/domoritz) for his questions and feedbacks.


pkgId: b42a83d7b350e550c3ef674603f7c82d8aa739641ee9b9adb79c4b6334d6e957
name: python-cm-cluster-on-demand
arch: src
version: 10.0.9
epoch: 0
release: 1
summary: Bright Cluster on Demand Utility
url: https://www.brightcomputing.com/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cm-cluster-on-demand-10.0.9-1.src.rpm
checksum_type: sha256
description:
  With Cluster on Demand you can spin up a cluster running Bright Cluster Manager.

  This package is a supporting package, for the full COD client packages check:
  - cm-cluster-on-demand-aws
  - cm-cluster-on-demand-azure
  - cm-cluster-on-demand-oci


pkgId: 88edc491ed63388dd0e2bc489ea9fa9c48d80b91faa2e4ae4f5f1ce50e1db338
name: python-cm-cluster-on-demand-config
arch: src
version: 10.0.9
epoch: 0
release: 1
summary: Bright Computing COD configuration library
url: https://www.brightcomputing.com/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cm-cluster-on-demand-config-10.0.9-1.src.rpm
checksum_type: sha256
description:
  With Cluster on Demand you can spin up a cluster running Bright Cluster Manager.

  This package is a supporting package, for the full COD client packages check:
  - cm-cluster-on-demand-aws
  - cm-cluster-on-demand-azure


pkgId: 21f69c193c4a5b31937b5604d47420d923b7c235591eb40ba233978db23662d1
name: python-cm-course-uos
arch: src
version: 1.5.15
epoch: 0
release: 1
summary: This package hosts code required to run the colab notebooks which host the course assignemnts.
url: https://github.com/denizmgun/cm-course-uos
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cm-course-uos-1.5.15-1.src.rpm
checksum_type: sha256
description:
  The package is separated into submodules "ps1","ps2".. which respectively host the code for each problem set. The main reasons this package was created were hiding unnecessary complexity from the students and enabling us to perform automating testing, grading and task aids while discouraging cheating. Cheating is still possible by installing the package and reverse engineering the functions but the effort would be better spent on solving the task.


pkgId: f42cf193dcb59eac45b7585b092fe49851855388f586d5bf0075590d481ef1a9
name: python-cm-time
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: A simple context manager that measures time using perf_counter()
url: https://github.com/34j/cm-time
rpm_license: CC0-1.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cm-time-0.1.2-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://github.com/34j/cm-time/actions?query=workflow%3ACI">
      <img src="https://img.shields.io/github/workflow/status/34j/cm-time/CI/main?label=CI&logo=github&style=flat-square" alt="CI Status" >
    </a>
    <a href="https://cm-time.readthedocs.io">
      <img src="https://img.shields.io/readthedocs/cm-time.svg?logo=read-the-docs&logoColor=fff&style=flat-square" alt="Documentation Status">
    </a>
    <a href="https://codecov.io/gh/34j/cm-time">
      <img src="https://img.shields.io/codecov/c/github/34j/cm-time.svg?logo=codecov&logoColor=fff&style=flat-square" alt="Test coverage percentage">
    </a>
  </p>
  <p align="center">
    <a href="https://python-poetry.org/">
      <img src="https://img.shields.io/badge/packaging-poetry-299bd7?style=flat-square&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAASCAYAAABrXO8xAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAJJSURBVHgBfZLPa1NBEMe/s7tNXoxW1KJQKaUHkXhQvHgW6UHQQ09CBS/6V3hKc/AP8CqCrUcpmop3Cx48eDB4yEECjVQrlZb80CRN8t6OM/teagVxYZi38+Yz853dJbzoMV3MM8cJUcLMSUKIE8AzQ2PieZzFxEJOHMOgMQQ+dUgSAckNXhapU/NMhDSWLs1B24A8sO1xrN4NECkcAC9ASkiIJc6k5TRiUDPhnyMMdhKc+Zx19l6SgyeW76BEONY9exVQMzKExGKwwPsCzza7KGSSWRWEQhyEaDXp6ZHEr416ygbiKYOd7TEWvvcQIeusHYMJGhTwF9y7sGnSwaWyFAiyoxzqW0PM/RjghPxF2pWReAowTEXnDh0xgcLs8l2YQmOrj3N7ByiqEoH0cARs4u78WgAVkoEDIDoOi3AkcLOHU60RIg5wC4ZuTC7FaHKQm8Hq1fQuSOBvX/sodmNJSB5geaF5CPIkUeecdMxieoRO5jz9bheL6/tXjrwCyX/UYBUcjCaWHljx1xiX6z9xEjkYAzbGVnB8pvLmyXm9ep+W8CmsSHQQY77Zx1zboxAV0w7ybMhQmfqdmmw3nEp1I0Z+FGO6M8LZdoyZnuzzBdjISicKRnpxzI9fPb+0oYXsNdyi+d3h9bm9MWYHFtPeIZfLwzmFDKy1ai3p+PDls1Llz4yyFpferxjnyjJDSEy9CaCx5m2cJPerq6Xm34eTrZt3PqxYO1XOwDYZrFlH1fWnpU38Y9HRze3lj0vOujZcXKuuXm3jP+s3KbZVra7y2EAAAAAASUVORK5CYII=" alt="Poetry">
    </a>
    <a href="https://github.com/ambv/black">
      <img src="https://img.shields.io/badge/code%20style-black-000000.svg?style=flat-square" alt="black">
    </a>
    <a href="https://github.com/pre-commit/pre-commit">
      <img src="https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=flat-square" alt="pre-commit">
    </a>
  </p>
  <p align="center">
    <a href="https://pypi.org/project/cm-time/">
      <img src="https://img.shields.io/pypi/v/cm-time.svg?logo=python&logoColor=fff&style=flat-square" alt="PyPI Version">
    </a>
    <img src="https://img.shields.io/pypi/pyversions/cm-time.svg?style=flat-square&logo=python&amp;logoColor=fff" alt="Supported Python versions">
    <img src="https://img.shields.io/pypi/l/cm-time.svg?style=flat-square" alt="License">
  </p>

  A simple context manager that measures time using perf_counter()



  Install this via pip (or your favourite package manager):

  `pip install cm-time`



  ```python
  from cm_time import timer

  with timer() as t:
        pass

  print(t.elapsed)
  ```

  Output:

  ```shell
  Elapsed time: 0.000
  0.0
  ```

  ```python
  from cm_time import timer_wrapped

  @timer_wrapped()
  def foo():
      pass
  ```

  Output:

  ```shell
  foo: Elapsed time: 0.000
  ```



  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

  <!-- prettier-ignore-start -->
  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- markdownlint-disable -->
  <!-- markdownlint-enable -->
  <!-- ALL-CONTRIBUTORS-LIST:END -->
  <!-- prettier-ignore-end -->

  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!



  This package was created with
  [Copier](https://copier.readthedocs.io/) and the
  [browniebroke/pypackage-template](https://github.com/browniebroke/pypackage-template)
  project template.


pkgId: 815045bd59b59ed1dab3ac54998782be1b7b6f33958a5757bfb7f4b26f7be855
name: python-cma
arch: src
version: 4.0.0
epoch: 0
release: 1
url: https://github.com/CMA-ES/pycma
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cma-4.0.0-1.src.rpm
checksum_type: sha256
summary:
  CMA-ES, Covariance Matrix Adaptation Evolution Strategy for non-linear numerical optimization in Python

description:
  A stochastic numerical optimization algorithm for difficult (non-convex,
  ill-conditioned, multi-modal, rugged, noisy) optimization problems in
  continuous search spaces, implemented in Python.
  Typical domain of application are bound-constrained or unconstrained
  objective functions with:
  * search space dimension between, say, 5 and (a few) 100,
  * no gradients available,
  * at least, say, 100 times dimension function evaluations needed to
    get satisfactory solutions,
  * non-separable, ill-conditioned, or rugged/multi-modal landscapes.
  The CMA-ES is quite reliable, however for small budgets (fewer function
  evaluations than, say, 100 times dimension) or in very small dimensions
  better (i.e. faster) methods are available.
  The ``pycma`` module provides two independent implementations of the
  CMA-ES algorithm in the classes ``cma.CMAEvolutionStrategy`` and
  ``cma.purecma.CMAES``.


pkgId: a70d98b0a65175d9e087818612f46b410cdf05df6af3757ee4ec2fa04d4f11b9
name: python-cmaes
arch: src
version: 0.11.1
epoch: 0
release: 1
summary: Lightweight Covariance Matrix Adaptation Evolution Strategy (CMA-ES) implementation for Python 3.
url: https://github.com/CyberAgentAILab/cmaes
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmaes-0.11.1-1.src.rpm
checksum_type: sha256
description:
  [![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square)](./LICENSE) [![PyPI - Downloads](https://img.shields.io/pypi/dw/cmaes)](https://pypistats.org/packages/cmaes)

  :whale: [**Paper is now available on arXiv!**](https://arxiv.org/abs/2402.01373)

  *Simple* and *Practical* Python library for CMA-ES.
  Please refer to the [paper](https://arxiv.org/abs/2402.01373) [Nomura and Shibata 2024] for detailed information, including the design philosophy and advanced examples.

  ![visualize-six-hump-camel](https://user-images.githubusercontent.com/5564044/73486622-db5cff00-43e8-11ea-98fb-8246dbacab6d.gif)



  Supported Python versions are 3.7 or later.

  ```
  $ pip install cmaes
  ```

  Or you can install via [conda-forge](https://anaconda.org/conda-forge/cmaes).

  ```
  $ conda install -c conda-forge cmaes
  ```



  This library provides an "ask-and-tell" style interface. We employ the standard version of CMA-ES [Hansen 2016].

  ```python
  import numpy as np
  from cmaes import CMA

  def quadratic(x1, x2):
      return (x1 - 3) ** 2 + (10 * (x2 + 2)) ** 2

  if __name__ == "__main__":
      optimizer = CMA(mean=np.zeros(2), sigma=1.3)

      for generation in range(50):
          solutions = []
          for _ in range(optimizer.population_size):
              x = optimizer.ask()
              value = quadratic(x[0], x[1])
              solutions.append((x, value))
              print(f"#{generation} {value} (x1={x[0]}, x2 = {x[1]})")
          optimizer.tell(solutions)
  ```

  And you can use this library via [Optuna](https://github.com/optuna/optuna) [Akiba et al. 2019], an automatic hyperparameter optimization framework.
  Optuna's built-in CMA-ES sampler which uses this library under the hood is available from [v1.3.0](https://github.com/optuna/optuna/releases/tag/v1.3.0) and stabled at [v2.0.0](https://github.com/optuna/optuna/releases/tag/v2.2.0).
  See [the documentation](https://optuna.readthedocs.io/en/stable/reference/samplers/generated/optuna.samplers.CmaEsSampler.html) or [v2.0 release blog](https://medium.com/optuna/optuna-v2-3165e3f1fc2) for more details.

  ```python
  import optuna

  def objective(trial: optuna.Trial):
      x1 = trial.suggest_uniform("x1", -4, 4)
      x2 = trial.suggest_uniform("x2", -4, 4)
      return (x1 - 3) ** 2 + (10 * (x2 + 2)) ** 2

  if __name__ == "__main__":
      sampler = optuna.samplers.CmaEsSampler()
      study = optuna.create_study(sampler=sampler)
      study.optimize(objective, n_trials=250)
  ```





  The performance of the CMA-ES can deteriorate when faced with *difficult* problems such as multimodal or noisy ones, if its hyperparameter values are not properly configured.
  The Learning Rate Adaptation CMA-ES (LRA-CMA) effectively addresses this issue by autonomously adjusting the learning rate.
  Consequently, LRA-CMA eliminates the need for expensive hyperparameter tuning.

  LRA-CMA can be used by simply adding `lr_adapt=True` to the initialization of `CMA()`.

  <details>

  <summary>Source code</summary>

  ```python
  import numpy as np
  from cmaes import CMA


  def rastrigin(x):
      dim = len(x)
      return 10 * dim + sum(x**2 - 10 * np.cos(2 * np.pi * x))


  if __name__ == "__main__":
      dim = 40
      optimizer = CMA(mean=3*np.ones(dim), sigma=2.0, lr_adapt=True)

      for generation in range(50000):
          solutions = []
          for _ in range(optimizer.population_size):
              x = optimizer.ask()
              value = rastrigin(x)
              if generation % 500 == 0:
                  print(f"#{generation} {value}")
              solutions.append((x, value))
          optimizer.tell(solutions)

          if optimizer.should_stop():
              break
  ```

  The full source code is available [here](./examples/lra_cma.py).

  </details>





  Warm Starting CMA-ES (WS-CMA) is a method that transfers prior knowledge from similar tasks through the initialization of the CMA-ES.
  This is useful especially when the evaluation budget is limited (e.g., hyperparameter optimization of machine learning algorithms).

  ![benchmark-lightgbm-toxic](https://github.com/c-bata/benchmark-warm-starting-cmaes/raw/main/result.png)

  <details>
  <summary>Source code</summary>

  ```python
  import numpy as np
  from cmaes import CMA, get_warm_start_mgd

  def source_task(x1: float, x2: float) -> float:
      b = 0.4
      return (x1 - b) ** 2 + (x2 - b) ** 2

  def target_task(x1: float, x2: float) -> float:
      b = 0.6
      return (x1 - b) ** 2 + (x2 - b) ** 2

  if __name__ == "__main__":
      
      source_solutions = []
      for _ in range(1000):
          x = np.random.random(2)
          value = source_task(x[0], x[1])
          source_solutions.append((x, value))

      
      
      ws_mean, ws_sigma, ws_cov = get_warm_start_mgd(
          source_solutions, gamma=0.1, alpha=0.1
      )
      optimizer = CMA(mean=ws_mean, sigma=ws_sigma, cov=ws_cov)

      
      print(" g    f(x1,x2)     x1      x2  ")
      print("===  ==========  ======  ======")
      while True:
          solutions = []
          for _ in range(optimizer.population_size):
              x = optimizer.ask()
              value = target_task(x[0], x[1])
              solutions.append((x, value))
              print(
                  f"{optimizer.generation:3d}  {value:10.5f}"
                  f"  {x[0]:6.2f}  {x[1]:6.2f}"
              )
          optimizer.tell(solutions)

          if optimizer.should_stop():
              break
  ```

  The full source code is available [here](./examples/ws_cma.py).

  </details>




  CMA-ES with Margin (CMAwM) introduces a lower bound on the marginal probability for each discrete dimension, ensuring that samples avoid being fixed to a single point.
  This method can be applied to mixed spaces consisting of continuous (such as float) and discrete elements (including integer and binary types).

  |CMA|CMAwM|
  |---|---|
  |![CMA-ES](https://github.com/CyberAgentAILab/cmaes/assets/27720055/41d33c4b-b80b-42af-9f62-6d22f19dbae5)|![CMA-ESwM](https://github.com/CyberAgentAILab/cmaes/assets/27720055/9035deaa-6222-4720-a417-c31c765f3228)|

  The above figures are taken from [EvoConJP/CMA-ES_with_Margin](https://github.com/EvoConJP/CMA-ES_with_Margin).

  <details>
  <summary>Source code</summary>

  ```python
  import numpy as np
  from cmaes import CMAwM


  def ellipsoid_onemax(x, n_zdim):
      n = len(x)
      n_rdim = n - n_zdim
      r = 10
      if len(x) < 2:
          raise ValueError("dimension must be greater one")
      ellipsoid = sum([(1000 ** (i / (n_rdim - 1)) * x[i]) ** 2 for i in range(n_rdim)])
      onemax = n_zdim - (0.0 < x[(n - n_zdim) :]).sum()
      return ellipsoid + r * onemax


  def main():
      binary_dim, continuous_dim = 10, 10
      dim = binary_dim + continuous_dim
      bounds = np.concatenate(
          [
              np.tile([-np.inf, np.inf], (continuous_dim, 1)),
              np.tile([0, 1], (binary_dim, 1)),
          ]
      )
      steps = np.concatenate([np.zeros(continuous_dim), np.ones(binary_dim)])
      optimizer = CMAwM(mean=np.zeros(dim), sigma=2.0, bounds=bounds, steps=steps)
      print(" evals    f(x)")
      print("======  ==========")

      evals = 0
      while True:
          solutions = []
          for _ in range(optimizer.population_size):
              x_for_eval, x_for_tell = optimizer.ask()
              value = ellipsoid_onemax(x_for_eval, binary_dim)
              evals += 1
              solutions.append((x_for_tell, value))
              if evals % 300 == 0:
                  print(f"{evals:5d}  {value:10.5f}")
          optimizer.tell(solutions)

          if optimizer.should_stop():
              break


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

  Source code is also available [here](./examples/cmaes_with_margin.py).

  </details>



  CatCMA is a method for mixed-category optimization problems, which is the problem of simultaneously optimizing continuous and categorical variables. CatCMA employs the joint probability distribution of multivariate Gaussian and categorical distributions as the search distribution.

  ![CatCMA](https://github.com/CyberAgentAILab/cmaes/assets/27720055/f91443b6-d71b-4849-bfc3-095864f7c58c)

  <details>
  <summary>Source code</summary>

  ```python
  import numpy as np
  from cmaes import CatCMA


  def sphere_com(x, c):
      dim_co = len(x)
      dim_ca = len(c)
      if dim_co < 2:
          raise ValueError("dimension must be greater one")
      sphere = sum(x * x)
      com = dim_ca - sum(c[:, 0])
      return sphere + com


  def rosenbrock_clo(x, c):
      dim_co = len(x)
      dim_ca = len(c)
      if dim_co < 2:
          raise ValueError("dimension must be greater one")
      rosenbrock = sum(100 * (x[:-1] ** 2 - x[1:]) ** 2 + (x[:-1] - 1) ** 2)
      clo = dim_ca - (c[:, 0].argmin() + c[:, 0].prod() * dim_ca)
      return rosenbrock + clo


  def mc_proximity(x, c, cat_num):
      dim_co = len(x)
      dim_ca = len(c)
      if dim_co < 2:
          raise ValueError("dimension must be greater one")
      if dim_co != dim_ca:
          raise ValueError(
              "number of dimensions of continuous and categorical variables "
              "must be equal in mc_proximity"
          )

      c_index = np.argmax(c, axis=1) / cat_num
      return sum((x - c_index) ** 2) + sum(c_index)


  if __name__ == "__main__":
      cont_dim = 5
      cat_dim = 5
      cat_num = np.array([3, 4, 5, 5, 5])
      
      optimizer = CatCMA(mean=3.0 * np.ones(cont_dim), sigma=1.0, cat_num=cat_num)

      for generation in range(200):
          solutions = []
          for _ in range(optimizer.population_size):
              x, c = optimizer.ask()
              value = mc_proximity(x, c, cat_num)
              if generation % 10 == 0:
                  print(f"#{generation} {value}")
              solutions.append(((x, c), value))
          optimizer.tell(solutions)

          if optimizer.should_stop():
              break
  ```

  The full source code is available [here](./examples/catcma.py).

  </details>




  Sep-CMA-ES is an algorithm that limits the covariance matrix to a diagonal form.
  This reduction in the number of parameters enhances scalability, making Sep-CMA-ES well-suited for high-dimensional optimization tasks.
  Additionally, the learning rate for the covariance matrix is increased, leading to superior performance over the (full-covariance) CMA-ES on separable functions.

  <details>
  <summary>Source code</summary>

  ```python
  import numpy as np
  from cmaes import SepCMA

  def ellipsoid(x):
      n = len(x)
      if len(x) < 2:
          raise ValueError("dimension must be greater one")
      return sum([(1000 ** (i / (n - 1)) * x[i]) ** 2 for i in range(n)])

  if __name__ == "__main__":
      dim = 40
      optimizer = SepCMA(mean=3 * np.ones(dim), sigma=2.0)
      print(" evals    f(x)")
      print("======  ==========")

      evals = 0
      while True:
          solutions = []
          for _ in range(optimizer.population_size):
              x = optimizer.ask()
              value = ellipsoid(x)
              evals += 1
              solutions.append((x, value))
              if evals % 3000 == 0:
                  print(f"{evals:5d}  {value:10.5f}")
          optimizer.tell(solutions)

          if optimizer.should_stop():
              break
  ```

  Full source code is available [here](./examples/sep_cma.py).

  </details>



  IPOP-CMA-ES is a method that involves restarting the CMA-ES with an incrementally increasing population size, as described below.

  ![visualize-ipop-cmaes-himmelblau](https://user-images.githubusercontent.com/5564044/88472274-f9e12480-cf4b-11ea-8aff-2a859eb51a15.gif)

  <details>
  <summary>Source code</summary>

  ```python
  import math
  import numpy as np
  from cmaes import CMA

  def ackley(x1, x2):
      
      return (
          -20 * math.exp(-0.2 * math.sqrt(0.5 * (x1 ** 2 + x2 ** 2)))
          - math.exp(0.5 * (math.cos(2 * math.pi * x1) + math.cos(2 * math.pi * x2)))
          + math.e + 20
      )

  if __name__ == "__main__":
      bounds = np.array([[-32.768, 32.768], [-32.768, 32.768]])
      lower_bounds, upper_bounds = bounds[:, 0], bounds[:, 1]

      mean = lower_bounds + (np.random.rand(2) * (upper_bounds - lower_bounds))
      sigma = 32.768 * 2 / 5  # 1/5 of the domain width
      optimizer = CMA(mean=mean, sigma=sigma, bounds=bounds, seed=0)

      for generation in range(200):
          solutions = []
          for _ in range(optimizer.population_size):
              x = optimizer.ask()
              value = ackley(x[0], x[1])
              solutions.append((x, value))
              print(f"#{generation} {value} (x1={x[0]}, x2 = {x[1]})")
          optimizer.tell(solutions)

          if optimizer.should_stop():
              
              popsize = optimizer.population_size * 2
              mean = lower_bounds + (np.random.rand(2) * (upper_bounds - lower_bounds))
              optimizer = CMA(mean=mean, sigma=sigma, population_size=popsize)
              print(f"Restart CMA-ES with popsize={popsize}")
  ```

  Full source code is available [here](./examples/ipop_cma.py).

  </details>


  If you use our library in your work, please cite our paper:

  Masahiro Nomura, Masashi Shibata.<br>
  **cmaes : A Simple yet Practical Python Library for CMA-ES**<br>
  [https://arxiv.org/abs/2402.01373](https://arxiv.org/abs/2402.01373)

  Bibtex:
  ```
  @article{nomura2024cmaes,
    title={cmaes : A Simple yet Practical Python Library for CMA-ES},
    author={Nomura, Masahiro and Shibata, Masashi},
    journal={arXiv preprint arXiv:2402.01373},
    year={2024}
  }
  ```


  For any questions, feel free to raise an issue or contact me at nomura_masahiro@cyberagent.co.jp.



  **Projects using cmaes:**

  * [Optuna](https://github.com/optuna/optuna) : A hyperparameter optimization framework that supports CMA-ES using this library under the hood.
  * [Kubeflow/Katib](https://www.kubeflow.org/docs/components/katib/katib-config/) : Kubernetes-based system for hyperparameter tuning and neural architecture search
  * (If you are using `cmaes` in your project and would like it to be listed here, please submit a GitHub issue.)

  **Other libraries:**

  We have great respect for all libraries involved in CMA-ES.

  * [pycma](https://github.com/CMA-ES/pycma) : Most renowned CMA-ES implementation, created and maintained by Nikolaus Hansen.
  * [pymoo](https://github.com/msu-coinlab/pymoo) : A library for multi-objective optimization in Python.
  * [evojax](https://github.com/google/evojax) : evojax offers a JAX-port of this library.
  * [evosax](https://github.com/RobertTLange/evosax) : evosax provides a JAX-based implementation of CMA-ES and sep-CMA-ES, inspired by this library.

  **References:**

  * [Akiba et al. 2019] [T. Akiba, S. Sano, T. Yanase, T. Ohta, M. Koyama, Optuna: A Next-generation Hyperparameter Optimization Framework, KDD, 2019.](https://dl.acm.org/citation.cfm?id=3330701)
  * [Auger and Hansen 2005] [A. Auger, N. Hansen, A Restart CMA Evolution Strategy with Increasing Population Size, CEC, 2005.](http://www.cmap.polytechnique.fr/~nikolaus.hansen/cec2005ipopcmaes.pdf)
  * [Hamano et al. 2022] [R. Hamano, S. Saito, M. Nomura, S. Shirakawa, CMA-ES with Margin: Lower-Bounding Marginal Probability for Mixed-Integer Black-Box Optimization, GECCO, 2022.](https://arxiv.org/abs/2205.13482)
  * [Hamano et al. 2024] [R. Hamano, S. Saito, M. Nomura, K. Uchida, S. Shirakawa, CatCMA : Stochastic Optimization for Mixed-Category Problems, GECCO, 2024.](https://arxiv.org/abs/2405.09962)
  * [Hansen 2016] [N. Hansen, The CMA Evolution Strategy: A Tutorial. arXiv:1604.00772, 2016.](https://arxiv.org/abs/1604.00772)
  * [Nomura et al. 2021] [M. Nomura, S. Watanabe, Y. Akimoto, Y. Ozaki, M. Onishi, Warm Starting CMA-ES for Hyperparameter Optimization, AAAI, 2021.](https://arxiv.org/abs/2012.06932)
  * [Nomura et al. 2023] [M. Nomura, Y. Akimoto, I. Ono, CMA-ES with Learning
  Rate Adaptation: Can CMA-ES with Default Population Size Solve Multimodal
  and Noisy Problems?, GECCO, 2023.](https://arxiv.org/abs/2304.03473)
  * [Nomura and Shibata 2024] [M. Nomura, M. Shibata, cmaes : A Simple yet Practical Python Library for CMA-ES, arXiv:2402.01373, 2024.](https://arxiv.org/abs/2402.01373)
  * [Ros and Hansen 2008] [R. Ros, N. Hansen, A Simple Modification in CMA-ES Achieving Linear Time and Space Complexity, PPSN, 2008.](https://hal.inria.fr/inria-00287367/document)

rpm_license:
  MIT License  Copyright (c) 2020 CyberAgent, Inc.  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: 768957d300755cad6f4b7191574da001985532e82101115f8ad503bc475772c2
name: python-cmake-build-extension
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Setuptools extension to build and package CMake projects.
url: https://github.com/diegoferigo/cmake-build-extension
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmake-build-extension-0.6.1-1.src.rpm
checksum_type: sha256
description:
  [![Version](https://img.shields.io/pypi/v/cmake-build-extension.svg)][pypi]
  [![Python versions](https://img.shields.io/pypi/pyversions/cmake-build-extension.svg)][pypi]
  [![Status](https://img.shields.io/pypi/status/cmake-build-extension.svg)][pypi]
  [![Format](https://img.shields.io/pypi/format/cmake-build-extension.svg)][pypi]
  [![License](https://img.shields.io/pypi/l/cmake-build-extension.svg)][pypi]
  [![Python CI/CD](https://github.com/diegoferigo/cmake-build-extension/workflows/Python%20CI/CD/badge.svg)][ci_cd]

  [pypi]: https://pypi.org/project/cmake-build-extension/
  [ci_cd]: https://github.com/diegoferigo/cmake-build-extension/actions/workflows/python.yml

  **Setuptools extension to build and package CMake projects.**

  This project aims to simplify the integration of C++ projects based on CMake with Python packaging tools.
  CMake provides out-of-the-box support to either [SWIG][swig] and [pybind11][pybind11],
  that are two among the most used projects to create Python bindings from C++ sources.

  [swig]: https://github.com/swig/swig
  [pybind11]: https://github.com/pybind/pybind11

  If you have any experience with these hybrid projects, you know the challenges to make packaging right!
  This project takes inspiration from pre-existing examples
  ([`pybind/cmake_example`][pybind11_example], among many others)
  and provides a simple, flexible, and reusable setuptools extension with the following features:

  - Bridge between CMake projects and Python packaging.
  - Configure and build the CMake project from `setup.py`.
  - Install the CMake project in the resulting Python package.
  - Allow passing custom CMake options.
  - Allow creating a top-level `__init__.py`.
  - Expose C++ executables to the Python environment.
  - Provide a context manager to import reliably CPython modules on all major OSs.
  - Disable the C++ extension in editable installations (requiring to manually call CMake to install the C++ project).

  [pybind11_example]: https://github.com/pybind/cmake_example

  Have a look to the [example](example/) for an overview of what can be done with this extension.
  It shows how to create SWIG and pybind11 bindings for a project composed by a small C++ library with NumPy support
  and an executable.



  1. This extension supports creating packages [PEP517] and [PEP518] compliant ([more details][pyproject]).
  2. If the CMake project [exports the targets][export_targets], downstream projects can:
     1. Extend their `CMAKE_MODULE_PATH` with the root of your installed Python package,
        that could be obtained with:
        ```bash
        python -c "import <pkg>, pathlib; print(pathlib.Path(<pkg>.__file__).parent)"
        ```
        and consume the exported CMake targets.
     1. Use `cmake-build-extension` with the `cmake_depends_on` option and link against the exported CMake targets
        during the downstream packaging.

  Note that the second feature allows distributing C++ dependencies through PyPI.
  The resulting package structure is similar to other projects like [pybind11][pybind11_pypi] and [CasADi][casadi_pypi].
  Be aware that ensuring ABI compatibility could be problematic in edge cases,
  and the usage of a proper [compatible release pattern][pep440] (`~=`) could be necessary.

  [pep440]: https://www.python.org/dev/peps/pep-0440/#compatible-release
  [pep517]: https://www.python.org/dev/peps/pep-0517/
  [pep518]: https://www.python.org/dev/peps/pep-0518/

  [pyproject]: https://snarky.ca/what-the-heck-is-pyproject-toml/
  [export_targets]: https://cmake.org/cmake/help/git-stage/guide/importing-exporting/index.html

  [pybind11_pypi]: https://pypi.org/project/pybind11/
  [casadi_pypi]: https://pypi.org/project/casadi/



  From PyPI:

  ```bash
  pip install cmake-build-extension
  ```

  From the repository:

  ```bash
  pip install git+https://github.com/diegoferigo/cmake-build-extension
  ```



  Once both CMake project and `setup.py|setup.cfg|pyproject.toml` of your hybrid package are correctly configured
  to use the resources provided by cmake-build-extension, the following commands can be used:

  ```bash





  python setup.py sdist


  python -m build --sdist






  python setup.py bdist_wheel


  pip wheel -w dist/ .


  python -m build --wheel






  python setup.py {bdist_wheel|install} build_ext -D"BAR=Foo;VAR=TRUE"


  pip {wheel|install} --global-option="build_ext" --global-option="-DBAR=Foo;VAR=TRUE" .


  python -m build --wheel "-C--global-option=build_ext" "-C--global-option=-DBAR=Foo;VAR=TRUE"
  ```





  This extension, beyond packaging the hybrid C++ / Python project,
  also allows the inclusion of the exported CMake targets in the resulting wheel.
  This result depends on how the CMake project is configured,
  and whether the [exported targets][exp_imp_wiki] are installed together with the other files.

  [exp_imp_wiki]: https://gitlab.kitware.com/cmake/community/-/wikis/doc/tutorials/Exporting-and-Importing-Targets

  Such hybrid packages can then be uploaded to PyPI.
  Though, on GNU/Linux, the generated wheel is not compliant by default with any [`manylinux*`][manylinux] standard.
  Tools such [auditwheel][auditwheel] exist to fix these wheels, but they require running on selected distributions.
  Luckily, other projects like [cibuildwheel][cibuildwheel] greatly simplify the process in CI.

  [manylinux]: https://github.com/pypa/manylinux
  [auditwheel]: https://github.com/pypa/auditwheel
  [cibuildwheel]: https://github.com/joerick/cibuildwheel

  This being said, `manylinux*` guidelines could still work against you.
  In fact, wheels supporting `manylinux2010|manylinux2014` are built [with gcc4][pep599_manylinux2014]
  that does not support the new C++11 ABIs.
  In few words, this means that the exported libraries bundled in the wheel cannot
  be imported in a downstream project using relatively new C++ standards!
  For more details visit [robotology/idyntree#776](https://github.com/robotology/idyntree/issues/776).

  [pep599_manylinux2014]: https://www.python.org/dev/peps/pep-0599/#the-manylinux2014-policy

  Luckily, the situation changed thanks to the finalization of [PEP600][pep600], i.e. `manylinuxX_YY` :tada:
  If you build a PEP600 compliant wheel (nowadays compatible with most of the commonly used distributions),
  your exported CMake project bundled in the wheel can be successfully imported downstream.
  If you want to support this use case, make sure to produce and distribute wheels compliant with PEP600.

  [pep600]: https://www.python.org/dev/peps/pep-0600/



  Python 3.8 [changed][changelog_3_8] how DLL are resolved.
  By default, modules that could be imported in Python 3.7 stopped working, and using the new
  [`os.add_dll_directory`][add_dll_directory] is now necessary.

  In order to streamline the process, `cmake-build-extension` implements a context manager that can be used
  to import reliably the bindings module:

  ```python
  import cmake_build_extension

  with cmake_build_extension.build_extension_env():
      from . import bindings
  ```

  It will take care to temporarily fix the search path.

  For more details, refer to [#8][windows_import_issue] and [#12][windows_import_pr].

  [changelog_3_8]: https://docs.python.org/3/whatsnew/3.8.html#bpo-36085-whatsnew
  [add_dll_directory]: https://docs.python.org/3/library/os.html#os.add_dll_directory
  [windows_import_issue]: https://github.com/diegoferigo/cmake-build-extension/issues/8
  [windows_import_pr]: https://github.com/diegoferigo/cmake-build-extension/pull/12



  Sometimes hybrid projects are C++ centric, and keeping these files in the top-level folder is not desirable.
  In this setup, however, problems occur if the main `CMakeLists.txt` is kept in the top-level folder
  (see [pypa/build#322][sdist_issue]).
  To solve this problem, `cmake-build-extension` provides custom commands to create source distribution.
  You can use one of the following custom `sdist` options in `setup.py`:

  ```python
  setuptools.setup(
      cmdclass=dict(
          
          
          sdist=cmake_build_extension.GitSdistFolder,
          
          sdist=cmake_build_extension.GitSdistTree,
          
          
      ),
  )
  ```

  [sdist_issue]: https://github.com/pypa/build/issues/322



  If the provided example is not enough complex, find here below a list of projects using `cmake-build-extension`:

  - [`robotology/idyntree`](https://github.com/robotology/idyntree/)
  - [`robotology/yarp`](https://github.com/robotology/yarp/)
  - [`robotology/ycm`](https://github.com/robotology/ycm/)
  - [`diegoferigo/gazebo-yarp-synchronizer`](https://github.com/diegoferigo/gazebo-yarp-synchronizer)
  - [`robotology/gym-ignition@scenario`](https://github.com/robotology/gym-ignition/tree/devel/scenario)
  - [`dic-iit/gazebo-scenario-plugins`](https://github.com/dic-iit/gazebo-scenario-plugins/)
  - [`dic-iit/bipedal-locomotion-framework`](https://github.com/dic-iit/bipedal-locomotion-framework)
  - [`artivis/manif`](https://github.com/artivis/manif)



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



  [MIT](https://choosealicense.com/licenses/mit/)


pkgId: 9ecda0435a4fe08a983a7e4da7d10dd52242282763f090fc56b1a8bbb5876fa0
name: python-cmake-file-api
arch: src
version: 0.0.8.1
epoch: 0
release: 1
summary: Read and interpret CMake's file-based API
url: http://github.com/madebr/python-cmake-file-api
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmake-file-api-0.0.8.1-1.src.rpm
checksum_type: sha256
description:
  This library reads and interprets the files generated by [cmake's file-based API](https://cmake.org/cmake/help/git-stage/manual/cmake-file-api.7.html).



  - python 3
  - CMake 3.14+



  An example can be found in the [example](example/script.py) subdirectory.



  This project is licensed using the MIT license.


pkgId: 76fa61e5622b45c3cf46d74235584098111872b15897a775cfbb002703a3a9d5
name: python-cmakelint
arch: src
version: 1.4.3
epoch: 0
release: 1
summary: Static code checker for CMake files
url: https://github.com/cmake-lint/cmake-lint
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmakelint-1.4.3-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/cmake-lint/cmake-lint.svg?branch=develop)](https://travis-ci.org/cmake-lint/cmake-lint)
  ![PyPI](https://img.shields.io/pypi/v/cmakelint.svg)
  ![PyPI - Downloads](https://img.shields.io/pypi/dd/cmakelint.svg)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/cmakelint.svg)

  cmakelint parses CMake files and reports style issues.

  cmakelint requires Python.



  To install cmakelint from PyPI, run:

  .. code-block:: bash

      $ pip install cmakelint



      Syntax: cmakelint [--config=file] [--filter=-x,+y] <file> [file] ...
      filter=-x,+y,...
        Specify a comma separated list of filters to apply

      config=file
        Use the given file for configuration. By default the file
        $PWD/.cmakelintrc, ~/.config/cmakelintrc, $XDG_CONFIG_DIR/cmakelintrc or
        ~/.cmakelintrc is used if it exists. Use the value "None" to use no
        configuration file (./None for a file called literally None) Only the
        option "filter=" is currently supported in this file.

  Run the `--filter=` option with no filter to see available options. Currently
  these are:

      convention/filename
      linelength
      package/consistency
      readability/logic
      readability/mixedcase
      readability/wonkycase
      syntax
      whitespace/eol
      whitespace/extra
      whitespace/indent
      whitespace/mismatch
      whitespace/newline
      whitespace/tabs

  An example .cmakelintrc file would be as follows:

      filter=-whitespace/indent

  With this file in your home directory, running these commands would have the
  same effect:

      cmakelint.py CMakeLists.txt
      cmakelint.py --filter=-whitespace/indent CMakeLists.txt

  Filters can optionally be directly enabled/disabled from within a CMake file,
  overriding the configuration from file or CLI argument:

  ```





  ```

  cmakelint can also be run with [pre-commit](https://pre-commit.com). Add the following configuration block to your `.pre-commit-config.yaml`:

  ``` yaml
    - repo: https://github.com/cmake-lint/cmake-lint
      hooks:
        - id: cmakelint
  ```



  The program should exit with the following status codes:

  * 0 if everything went fine
  * 1 if an error message was issued
  * 32 on usage error


pkgId: 9f6e9fe894910325687b67ce39c46bdbe4b549687f580154192e7a16e8ad5efb
name: python-cmakerer
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Generates CMakeLists.txt files from arbitrary C/C++ codebases.
url: https://github.com/ChaosData/cmakerer
rpm_license: BSD (2 Clause)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmakerer-1.3.0-1.src.rpm
checksum_type: sha256
description:
  This script generates `CMakeLists.txt` from arbitrary C/C++ codebases. It is
  not intended to produce "buildable" cmake configurations, but instead enable
  CLion to load and index the code.



  ```bash
  pip3 install --user cmakerer
  ```

  ```bash
  python3 setup.py sdist bdist_wheel
  pip3 install --user dist/cmakerer-*.whl
  ```



  ```bash
  cmakerer -o ~/path/to/cpp/code/CMakeLists.txt -x src/windows -! tests -z ~/path/to/cpp/code
  ```



  * Detects both standard and system include paths.
  * Handles "multi-encoding" C/C++ files
  * Exclude directory paths with `-x`
  * Exclude (sub)directory segments with `-!`
  * Exclude cmake directories with `-z`
  * Add compiler defines with `-DVAR` or `-DVAR=value`
  * Deterministically add and remove paths with `-I`/`-S`/`-R`


pkgId: 6f42190f3cb7064f6a80ed914a67da0d57320fe2d8224eaacb504a8d792fdbbb
name: python-cmap
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Scientific colormaps for python, without dependencies
url: https://github.com/tlambert03/cmap
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmap-0.3.0-1.src.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/pypi/l/cmap.svg?color=green)](https://github.com/tlambert03/cmap/raw/main/LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/cmap.svg?color=green)](https://pypi.org/project/cmap)
  ![Conda](https://img.shields.io/conda/v/conda-forge/cmap)
  [![Python Version](https://img.shields.io/pypi/pyversions/cmap.svg?color=green)](https://python.org)
  [![CI](https://github.com/tlambert03/cmap/actions/workflows/ci.yml/badge.svg)](https://github.com/tlambert03/cmap/actions/workflows/ci.yml)
  [![codecov](https://codecov.io/gh/tlambert03/cmap/branch/main/graph/badge.svg)](https://codecov.io/gh/tlambert03/cmap)
  [![Documentation Status](https://readthedocs.org/projects/cmap-docs/badge/?version=latest)](https://cmap-docs.readthedocs.io/en/latest/?badge=latest)

  Scientific colormaps for python, with no dependencies beyond numpy.

  With `cmap`, you can use any of the colormaps from
  [matplotlib](https://matplotlib.org/stable/tutorials/colors/colormaps.html),
  [cmocean](https://matplotlib.org/cmocean/),
  [colorbrewer](https://colorbrewer2.org/),
  [crameri](https://www.fabiocrameri.ch/colourmaps/),
  [seaborn](https://seaborn.pydata.org/tutorial/color_palettes.html), and a host
  of other collections in your python code, without having to install matplotlib
  or any other dependencies beyond numpy.

  :book: [See the complete
  catalog](https://cmap-docs.readthedocs.io/en/latest/catalog/)

  There are a number of python libraries that provide or require colormaps or
  basic color support, but they all either depend on matplotlib, provide a
  specialized set of colormaps intended to extend those provided by matplotlib, or
  roll their own colormap solution that vendors/duplicates other libraries.

  `cmap` is a lightweight, library that provides a large collection of colormaps
  with no dependencies beyond numpy.  It provides exports to a number of known
  third-party colormap objects, allowing it to be used across a wide range of
  python visualization libraries.  The intention is to provide a library that can
  be used by any python library that needs colormaps, without forcing the user to
  install matplotlib (while still being compatible with matplotlib and other
  libraries that use matplotlib colormaps).

  `cmap` is strictly typed and fully tested, with a focus on good developer
  experience.



  ```
  pip install cmap
  ```

  ```
  conda install -c conda-forge cmap
  ```



  See [Documentation](https://cmap-docs.readthedocs.io/) for full details.



  The `cmap.Color` object is a simple wrapper around a tuple of RGBA scalars, with
  a few convenience methods for converting to other color objects.

  ```python
  from cmap import Color

  red = Color("red")  # or a variety of other "color like" inputs
  ```



  The `cmap.Colormap` object is a callable that can map a scalar value (or numpy
  array of values) to an RGBA color (or a numpy array of RGBA colors).  API is
  intended to mimic the behavior of a
  [`matplotlib.colors.Colormap`](https://matplotlib.org/stable/api/_as_gen/matplotlib.colors.Colormap.html#matplotlib.colors.Colormap)
  object (without requiring matplotlib)

  ```python
  In [1]: import cmap


  In [2]: cmap1 = cmap.Colormap(["red", "green", "blue"])

  In [3]: cmap1(np.linspace(0,1,5))
  Out[3]:
  array([[1.        , 0.        , 0.        , 1.        ],
         [0.50393701, 0.24900417, 0.        , 1.        ],
         [0.        , 0.50196078, 0.        , 1.        ],
         [0.        , 0.24900417, 0.50393701, 1.        ],
         [0.        , 0.        , 1.        , 1.        ]])
  ```

  Note that the input array must be normalized from 0-1, so if you're applying a colormap
  to an integer array (like an image) you must apply any contrast limits and rescale to
  0-1 before passing it to a `Colormap`.



  The `cmap.Colormap` object has convenience methods that export it to a number of known
  third-party colormap objects, including:

  - [matplotlib](https://matplotlib.org/)
  - [napari](https://napari.org/)
  - [vispy](https://vispy.org/)
  - [pygfx](https://pygfx.readthedocs.io/en/latest/) (& [fastplotlib](https://github.com/fastplotlib/fastplotlib))
  - [plotly](https://plotly.com/python/)
  - [bokeh](https://docs.bokeh.org/en/latest/)
  - [altair](https://altair-viz.github.io/)
  - [pyqtgraph](https://www.pyqtgraph.org/)

  See [documentation](https://cmap-docs.readthedocs.io/en/latest/colormaps/#usage-with-external-visualization-libraries)
  for details.

  If you would like to see support added for a particular library, please open an issue or PR.



  Other libraries providing colormaps:

  - [matplotlib](https://matplotlib.org/stable/tutorials/colors/colormaps.html)
  - [seaborn](https://seaborn.pydata.org/tutorial/color_palettes.html)  (subclasses matplotlib)
  - [proplot](https://proplot.readthedocs.io/en/latest/colormaps.html)  (subclasses matplotlib)
  - [palettable](https://jiffyclub.github.io/palettable/) (mostly data, import doesn't depend on matplotlib, but usage largely does)
  - [cmocean](https://matplotlib.org/cmocean/) (mostly data, outputs matplotlib colormaps)
  - [colorcet](https://colorcet.holoviz.org/) (mostly data, usage requires either matplotlib or bokeh)
  - [cmasher](https://cmasher.readthedocs.io/) (requires matplotlib)
  - [cmyt](https://github.com/yt-project/cmyt) (requires matplotlib)
  - [cmcrameri](https://github.com/callumrollo/cmcrameri) (requires matplotlib, wraps <https://www.fabiocrameri.ch/colourmaps/>)
  - [distinctipy](https://github.com/alan-turing-institute/distinctipy)  (generates distinct color sets, only requires numpy)
  - [Farrow & Ball Matplotlib](https://github.com/vork/farrowandball) (requires matplotlib)
  - [mplcyberpunk](https://github.com/dhaitz/mplcyberpunk) (requires matplotlib)



  - [Choosing Colormaps in Matplotlib](https://matplotlib.org/stable/tutorials/colors/colormaps.html)
  - [A Better Default Colormap for Matplotlib | SciPy 2015 | Nathaniel Smith and Stéfan van der Walt](https://www.youtube.com/watch?v=xAoljeRJ3lU)
  - blog post for above video: <https://bids.github.io/colormap/>
  - [Origins of Colormaps, Cleve Moler, February 2, 2015](https://blogs.mathworks.com/cleve/2015/02/02/origins-of-colormaps/)
  - [Documenting the matplotlib colormaps, @endolith](https://gist.github.com/endolith/2719900)
  - [Color Map Advice for Scientific Visualization](https://www.kennethmoreland.com/color-advice/)
  - <https://colorcet.com/>, Peter Kovesi
  - [Kovesi: Good Colour Maps: How to Design Them.](https://arxiv.org/abs/1509.03700)
  - <https://www.fabiocrameri.ch/colourmaps/>


pkgId: b94d6d9003cf6e458ae960a973e0e46979bde1aa3667280e6625c065505b56ca
name: python-cmap
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Scientific colormaps for python, without dependencies
url: https://github.com/pyapp-kit/cmap
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmap-0.4.0-1.src.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/pypi/l/cmap.svg?color=green)](https://github.com/pyapp-kit/cmap/raw/main/LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/cmap.svg?color=green)](https://pypi.org/project/cmap)
  ![Conda](https://img.shields.io/conda/v/conda-forge/cmap)
  [![Python Version](https://img.shields.io/pypi/pyversions/cmap.svg?color=green)](https://python.org)
  [![CI](https://github.com/pyapp-kit/cmap/actions/workflows/ci.yml/badge.svg)](https://github.com/pyapp-kit/cmap/actions/workflows/ci.yml)
  [![codecov](https://codecov.io/gh/pyapp-kit/cmap/branch/main/graph/badge.svg)](https://codecov.io/gh/pyapp-kit/cmap)
  [![Documentation Status](https://readthedocs.org/projects/cmap-docs/badge/?version=latest)](https://cmap-docs.readthedocs.io/en/latest/?badge=latest)

  Scientific colormaps for python, with no dependencies beyond numpy.

  With `cmap`, you can use any of the colormaps from
  [matplotlib](https://matplotlib.org/stable/tutorials/colors/colormaps.html),
  [cmocean](https://matplotlib.org/cmocean/),
  [colorbrewer](https://colorbrewer2.org/),
  [crameri](https://www.fabiocrameri.ch/colourmaps/),
  [seaborn](https://seaborn.pydata.org/tutorial/color_palettes.html), and a host
  of other collections in your python code, without having to install matplotlib
  or any other dependencies beyond numpy.

  :book: [See the complete
  catalog](https://cmap-docs.readthedocs.io/en/latest/catalog/)

  There are a number of python libraries that provide or require colormaps or
  basic color support, but they all either depend on matplotlib, provide a
  specialized set of colormaps intended to extend those provided by matplotlib, or
  roll their own colormap solution that vendors/duplicates other libraries.

  `cmap` is a lightweight library that provides a large collection of colormaps
  with no dependencies beyond numpy.  It provides exports to a number of known
  third-party colormap objects, allowing it to be used across a wide range of
  python visualization libraries.  The intention is to provide a library that can
  be used by any python library that needs colormaps, without forcing the user to
  install matplotlib (while still being compatible with matplotlib and other
  libraries that use matplotlib colormaps).

  `cmap` is strictly typed and fully tested, with a focus on good developer
  experience.



  ```
  pip install cmap
  ```

  ```
  conda install -c conda-forge cmap
  ```



  See [Documentation](https://cmap-docs.readthedocs.io/) for full details.



  The `cmap.Color` object is a simple wrapper around a tuple of RGBA scalars, with
  a few convenience methods for converting to other color objects.

  ```python
  from cmap import Color

  red = Color("red")  # or a variety of other "color like" inputs
  ```



  The `cmap.Colormap` object is a callable that can map a scalar value (or numpy
  array of values) to an RGBA color (or a numpy array of RGBA colors).  API is
  intended to mimic the behavior of a
  [`matplotlib.colors.Colormap`](https://matplotlib.org/stable/api/_as_gen/matplotlib.colors.Colormap.html#matplotlib.colors.Colormap)
  object (without requiring matplotlib)

  ```python
  In [1]: import cmap


  In [2]: cmap1 = cmap.Colormap(["red", "green", "blue"])

  In [3]: cmap1(np.linspace(0,1,5))
  Out[3]:
  array([[1.        , 0.        , 0.        , 1.        ],
         [0.50393701, 0.24900417, 0.        , 1.        ],
         [0.        , 0.50196078, 0.        , 1.        ],
         [0.        , 0.24900417, 0.50393701, 1.        ],
         [0.        , 0.        , 1.        , 1.        ]])
  ```

  Note that the input array must be normalized from 0-1, so if you're applying a colormap
  to an integer array (like an image) you must apply any contrast limits and rescale to
  0-1 before passing it to a `Colormap`.



  The `cmap.Colormap` object has convenience methods that export it to a number of known
  third-party colormap objects, including:

  - [matplotlib](https://matplotlib.org/)
  - [napari](https://napari.org/)
  - [vispy](https://vispy.org/)
  - [pygfx](https://pygfx.readthedocs.io/en/latest/) (& [fastplotlib](https://github.com/fastplotlib/fastplotlib))
  - [plotly](https://plotly.com/python/)
  - [bokeh](https://docs.bokeh.org/en/latest/)
  - [altair](https://altair-viz.github.io/)
  - [pyqtgraph](https://www.pyqtgraph.org/)

  See [documentation](https://cmap-docs.readthedocs.io/en/latest/colormaps/#usage-with-external-visualization-libraries)
  for details.

  If you would like to see support added for a particular library, please open an issue or PR.



  Other libraries providing colormaps:

  - [matplotlib](https://matplotlib.org/stable/tutorials/colors/colormaps.html)
  - [seaborn](https://seaborn.pydata.org/tutorial/color_palettes.html)  (subclasses matplotlib)
  - [proplot](https://proplot.readthedocs.io/en/latest/colormaps.html)  (subclasses matplotlib)
  - [palettable](https://jiffyclub.github.io/palettable/) (mostly data, import doesn't depend on matplotlib, but usage largely does)
  - [cmocean](https://matplotlib.org/cmocean/) (mostly data, outputs matplotlib colormaps)
  - [colorcet](https://colorcet.holoviz.org/) (mostly data, usage requires either matplotlib or bokeh)
  - [cmasher](https://cmasher.readthedocs.io/) (requires matplotlib)
  - [cmyt](https://github.com/yt-project/cmyt) (requires matplotlib)
  - [cmcrameri](https://github.com/callumrollo/cmcrameri) (requires matplotlib, wraps <https://www.fabiocrameri.ch/colourmaps/>)
  - [distinctipy](https://github.com/alan-turing-institute/distinctipy)  (generates distinct color sets, only requires numpy)
  - [Farrow & Ball Matplotlib](https://github.com/vork/farrowandball) (requires matplotlib)
  - [mplcyberpunk](https://github.com/dhaitz/mplcyberpunk) (requires matplotlib)



  - [Choosing Colormaps in Matplotlib](https://matplotlib.org/stable/tutorials/colors/colormaps.html)
  - [A Better Default Colormap for Matplotlib | SciPy 2015 | Nathaniel Smith and Stéfan van der Walt](https://www.youtube.com/watch?v=xAoljeRJ3lU)
  - blog post for above video: <https://bids.github.io/colormap/>
  - [Origins of Colormaps, Cleve Moler, February 2, 2015](https://blogs.mathworks.com/cleve/2015/02/02/origins-of-colormaps/)
  - [Documenting the matplotlib colormaps, @endolith](https://gist.github.com/endolith/2719900)
  - [Color Map Advice for Scientific Visualization](https://www.kennethmoreland.com/color-advice/)
  - <https://colorcet.com/>, Peter Kovesi
  - [Kovesi: Good Colour Maps: How to Design Them.](https://arxiv.org/abs/1509.03700)
  - <https://www.fabiocrameri.ch/colourmaps/>


pkgId: 0b1bf0b8cd7934c21e8f015aa98762032906c563798359b7bb185cf22fc841c9
name: python-cmapPy
arch: src
version: 4.0.1
epoch: 0
release: 1
url: https://github.com/cmap/cmapPy
rpm_license: BSD 3-clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmapPy-4.0.1-1.src.rpm
checksum_type: sha256
summary:
  Assorted tools for interacting with .gct, .gctx files and other Connectivity Map (Broad Institute) data/tools

description:
  cmapPy: Tools for interacting with .gctx and .gct files, and other Connectivity Map resources. See our documentation at http://cmappy.readthedocs.io/en/latest/, and for more information on the file formats and available resources, please see clue.io/gctx.


pkgId: 498e03361b86d71125a4e19281da41928e66b31c2fdbbf4fb94e9b9ad24ada13
name: python-cmaqsatproc
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Processor to grid satellite data for comparison to CMAQ.
url: https://github.com/barronh/cmaqsatproc
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmaqsatproc-0.4.0-1.src.rpm
checksum_type: sha256
description:
  Satellite Processors designed for simple CMAQ comparisons.



  * convert L2 or L3 satellite products to L3 on CMAQ grids
    * 2-d species like total or tropospheric columns
    * n-d vairables like averaging kernels and scattering weights.
  * convert CMAQ concentrations to L3-like products
    * Apply satellite averaging kernels to CMAQ concentrations to make satellite-like CMAQ
    * Apply CMAQ to create alternative air mass factors to make CMAQ-like satellite products.



  `cmaqsatproc` has an easy full suite approach

  1. Operates on local files or dynamically finds remote files
    1. User can specify input files from their disk.
    2. Queries NASA's Common Metadata Repository (CMR) or NOAA AWS
  2. Allows for spatial subsetting based on a simple box.
    1. User can specify the box based on lat/lon
    2. The CMAQ grid can be used to automatically define the box.
  3. Provides L2 access as a dataframe or makes Level 3 data as a dataset
  4. [Simple instructions](COLABINSTALL.md) are provided to configure Google Colab.





  This example requires OpenDAP access configured on the machine, but does not
  require any local files (satellite or CMAQ).

  ```
  import cmaqsatproc as csp

  GDNAM = '12US1'
  date='2019-07-24'
  readername = 'TropOMINO2' # or TropOMIHCHO, VIIRS_AERDB, ...
  outpath = f'{readername}_{date}_{GDNAM}.nc'

  cg = csp.open_griddesc(GDNAM)
  satreader = csp.reader_dict[readername]

  l3 = satreader.cmr_to_level3(
      temporal=f'{date}T00:00:00Z/{date}T23:59:59Z',
      bbox=cg.csp.bbox(), grid=cg.csp.geodf, verbose=9
  )
  l3.to_netcdf(outpath)
  ```



  This example assumes you have downloaded satellite files. The code is largely
  the same as the previous. Instead of `cmr_to_level3`, it the method uses `glob`
  to make a list of files that it passes to `paths_to_level3`.

  ```
  from glob import glob
  import cmaqsatproc as csp

  GDNAM = '12US1'
  date='2019-07-24'
  readername = 'VIIRS_AERDB' # or TropOMIHCHO, VIIRS_AERDB, ...
  outpath = f'{readername}_{date}_{GDNAM}.nc'

  cg = csp.open_griddesc(GDNAM)
  satreader = csp.reader_dict[readername]

  paths = sorted(glob('AERDB_L2_VIIRS_SNPP*.nc'))
  l3 = satreader.paths_to_level3(
      paths, bbox=cg.csp.bbox(), grid=cg.csp.geodf, verbose=9
  )
  l3.to_netcdf(outpath)
  ```



  This example requires an output from one of the previous exmaples. The data
  from the level3 satellite output is combined with CMAQ to make a comparison.

  ```
  import cmaqsatproc as csp
  import xarray as xr

  GDNAM = '12US1'
  date='2019-07-24'
  readername = 'TropOMINO2'

  satreader = csp.reader_dict[readername]
  l3 = xr.open_dataset(f'{readername}_{date}_{GDNAM}.nc')

  qf = csp.open_ioapi(f'CCTM_CONC_{date}_{GDNAM}.nc')[['NO2']]
  mf = csp.open_ioapi(f'METCRO3D_{date}_{GDNAM}.nc')
  qf['DENS'] = mf['DENS']
  qf['ZF'] = mf['ZF']
  qf['PRES'] = mf['PRES']

  overf = satreader.cmaq_process(qf, l3)
  overf.to_netcdf(f'{readername}_{date}_{GDNAM}_CMAQ.nc')
  ```



  * Spatial matching is pretty good
    * For satellite products with pixel corners, fractional area weighting is used by default. Other options are avilable.
  * Satellite AveragingKernels are averaged
    * within a single day or overpass depending on configuration.
    * within grid cells.
  * CMAQ stratosphere is using one of several methods
    * Removed according to the satellite averaging kernel.



  * numpy
  * xarray
  * netcdf4
  * pyproj
  * pandas
  * geopandas
  * h5netcdf is required for s3 support



  OpenDAP is supported through standard NetCDF-C support. If authentication is
  required, configure `.netrc` and `.dodsrc`. The configuration is described
  several places. Although urls tend to update, the links below are currently useful:

  * https://disc.gsfc.nasa.gov/data-access
  * https://docs.unidata.ucar.edu/netcdf-c/current/auth.html
  * https://docs.opendap.org/index.php/DAP_Clients_-_Authentication

  To summarize those resources, make a user-access-only `.netrc` file. Then, make
  a `.dodsrc` file that points to the `.netrc` file and a `.urs_cookies` file.
  The commands below achieve this goal, but will overwrite anything you already
  have there:

  ```bash
  touch ~/.netrc
  touch ~/.urs_cookies
  chmod 0600 ~/.netrc
  cat << EOF > ~/.dodsrc
  HTTP.NETRC=${HOME}/.netrc
  HTTP.COOKIEJAR=${HOME}/.urs_cookies
  EOF

  cat << EOF >> ~/.netrc
  machine urs.earthdata.nasa.gov
    login <uid>
    password <password>
  EOF
  ```

  Notes:
  1. I have only been able to make this work if the files are in the user home directory.
  2. netcdf4-python version 1.6 has trouble with opendap.




  ```mermaid
  flowchart TB;
      subgraph userinputs [User Options];
      direction TB;
      query_opts(query options);
      localpaths[(local paths\nor urls)];
      grid(CMAQ grid);
      end
      subgraph cmaqsatproc [ ];
      direction TB;
      csplabel[cmaqsatproc];
      cmr_links[[cmr_links]];
      xarray -->to_dataframe[[to_dataframe]]
      xarray[[open_dataset]] -->to_level3[[to_level3]]
      end
      subgraph outputs
      direction LR;
      l3;
      csv;
      end
      subgraph CMR [. Common Metadata Repository .];
      direction TB;
      CMR_API[[CMR API]];
      NASA_DB[(NASA Database)];
      NASA_DB <--> CMR_API;
      end
      grid -->to_level3
      query_opts -->cmr_links;
      cmr_links <-->CMR_API;
      localpaths --> xarray;
      cmr_links -- OpenDAP links--> xarray;
      to_level3 --> l3[\Level3 NetCDF or CSV/];
      to_dataframe --> csv[\Level2 CSV/];
      style query_opts fill:#ff0,stroke:#333,stroke-width:4px
      style userinputs fill:#fff,stroke:#000,stroke-width:1px
      style outputs fill:#fff,stroke:#000,stroke-width:1px
      style grid fill:#ff0,stroke:#333,stroke-width:4px
      style localpaths fill:#ff0,stroke:#333,stroke-width:4px
      style CMR fill:#ccc,stroke:#333,stroke-width:4px
      style cmaqsatproc fill:#cefad0,stroke:#cefad0,stroke-width:4px
      style csplabel fill:#cefad0,stroke:#cefad0,stroke-width:4px
  ```



  Henderson, B. H. (2022, October 17). cmaqsatproc v2: Satellite data processing for CMAQ [Poster]. 21st Annual Community Modeling and Analysis System Conference, Chapel Hill, NC. https://www.cmascenter.org/conference/2022/agenda.cfm; [direct link](https://www.cmascenter.org/conference/2022/slides/Henderson_satellite-data-CMAS2022.pdf)


pkgId: fd3e4a933f4fe040cd59531c749c34e71c5663ce2fe634a0f869df0f790689c8
name: python-cmaqsatproc
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Processor to grid satellite data for comparison to CMAQ.
url: https://github.com/barronh/cmaqsatproc
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmaqsatproc-0.4.1-1.src.rpm
checksum_type: sha256
description:
  Satellite Processors designed for simple CMAQ comparisons.

  [![Docs](https://github.com/barronh/cmaqsatproc/actions/workflows/documentation.yaml/badge.svg)](https://barronh.github.io/cmaqsatproc/)




  * convert L2 or L3 satellite products to L3 on CMAQ grids
    * 2-d species like total or tropospheric columns
    * n-d vairables like averaging kernels and scattering weights.
  * convert CMAQ concentrations to L3-like products
    * Apply satellite averaging kernels to CMAQ concentrations to make satellite-like CMAQ
    * Apply CMAQ to create alternative air mass factors to make CMAQ-like satellite products.



  `cmaqsatproc` has an easy full suite approach

  1. Operates on local files or dynamically finds remote files
    1. User can specify input files from their disk.
    2. Queries NASA's Common Metadata Repository (CMR) or NOAA AWS
  2. Allows for spatial subsetting based on a simple box.
    1. User can specify the box based on lat/lon
    2. The CMAQ grid can be used to automatically define the box.
  3. Provides L2 access as a dataframe or makes Level 3 data as a dataset
  4. [Simple instructions](COLABINSTALL.md) are provided to configure Google Colab.





  This example requires OpenDAP access configured on the machine, but does not
  require any local files (satellite or CMAQ).

  ```
  import cmaqsatproc as csp

  GDNAM = '12US1'
  date='2019-07-24'
  readername = 'TropOMINO2' # or TropOMIHCHO, VIIRS_AERDB, ...
  outpath = f'{readername}_{date}_{GDNAM}.nc'

  cg = csp.open_griddesc(GDNAM)
  satreader = csp.reader_dict[readername]

  l3 = satreader.cmr_to_level3(
      temporal=f'{date}T00:00:00Z/{date}T23:59:59Z',
      bbox=cg.csp.bbox(), grid=cg.csp.geodf, verbose=9
  )
  l3.to_netcdf(outpath)
  ```



  This example assumes you have downloaded satellite files. The code is largely
  the same as the previous. Instead of `cmr_to_level3`, it the method uses `glob`
  to make a list of files that it passes to `paths_to_level3`.

  ```
  from glob import glob
  import cmaqsatproc as csp

  GDNAM = '12US1'
  date='2019-07-24'
  readername = 'VIIRS_AERDB' # or TropOMIHCHO, VIIRS_AERDB, ...
  outpath = f'{readername}_{date}_{GDNAM}.nc'

  cg = csp.open_griddesc(GDNAM)
  satreader = csp.reader_dict[readername]

  paths = sorted(glob('AERDB_L2_VIIRS_SNPP*.nc'))
  l3 = satreader.paths_to_level3(
      paths, bbox=cg.csp.bbox(), grid=cg.csp.geodf, verbose=9
  )
  l3.to_netcdf(outpath)
  ```



  This example requires an output from one of the previous exmaples. The data
  from the level3 satellite output is combined with CMAQ to make a comparison.

  ```
  import cmaqsatproc as csp
  import xarray as xr

  GDNAM = '12US1'
  date='2019-07-24'
  readername = 'TropOMINO2'

  satreader = csp.reader_dict[readername]
  l3 = xr.open_dataset(f'{readername}_{date}_{GDNAM}.nc')

  qf = csp.open_ioapi(f'CCTM_CONC_{date}_{GDNAM}.nc')[['NO2']]
  mf = csp.open_ioapi(f'METCRO3D_{date}_{GDNAM}.nc')
  qf['DENS'] = mf['DENS']
  qf['ZF'] = mf['ZF']
  qf['PRES'] = mf['PRES']

  overf = satreader.cmaq_process(qf, l3)
  overf.to_netcdf(f'{readername}_{date}_{GDNAM}_CMAQ.nc')
  ```



  * Spatial matching is pretty good
    * For satellite products with pixel corners, fractional area weighting is used by default. Other options are avilable.
  * Satellite AveragingKernels are averaged
    * within a single day or overpass depending on configuration.
    * within grid cells.
  * CMAQ stratosphere is using one of several methods
    * Removed according to the satellite averaging kernel.



  * numpy
  * xarray
  * netcdf4
  * pyproj
  * pandas
  * geopandas
  * h5netcdf is required for s3 support



  OpenDAP is supported through standard NetCDF-C support. If authentication is
  required, configure `.netrc` and `.dodsrc`. The configuration is described
  several places. Although urls tend to update, the links below are currently useful:

  * https://disc.gsfc.nasa.gov/data-access
  * https://docs.unidata.ucar.edu/netcdf-c/current/auth.html
  * https://docs.opendap.org/index.php/DAP_Clients_-_Authentication

  To summarize those resources, make a user-access-only `.netrc` file. Then, make
  a `.dodsrc` file that points to the `.netrc` file and a `.urs_cookies` file.
  The commands below achieve this goal, but will overwrite anything you already
  have there:

  ```bash
  touch ~/.netrc
  touch ~/.urs_cookies
  chmod 0600 ~/.netrc
  cat << EOF > ~/.dodsrc
  HTTP.NETRC=${HOME}/.netrc
  HTTP.COOKIEJAR=${HOME}/.urs_cookies
  EOF

  cat << EOF >> ~/.netrc
  machine urs.earthdata.nasa.gov
    login <uid>
    password <password>
  EOF
  ```

  Notes:
  1. I have only been able to make this work if the files are in the user home directory.
  2. netcdf4-python version 1.6 has trouble with opendap.




  ```mermaid
  flowchart TB;
      subgraph userinputs [User Options];
      direction TB;
      query_opts(query options);
      localpaths[(local paths\nor urls)];
      grid(CMAQ grid);
      end
      subgraph cmaqsatproc [ ];
      direction TB;
      csplabel[cmaqsatproc];
      cmr_links[[cmr_links]];
      xarray -->to_dataframe[[to_dataframe]]
      xarray[[open_dataset]] -->to_level3[[to_level3]]
      end
      subgraph outputs
      direction LR;
      l3;
      csv;
      end
      subgraph CMR [. Common Metadata Repository .];
      direction TB;
      CMR_API[[CMR API]];
      NASA_DB[(NASA Database)];
      NASA_DB <--> CMR_API;
      end
      grid -->to_level3
      query_opts -->cmr_links;
      cmr_links <-->CMR_API;
      localpaths --> xarray;
      cmr_links -- OpenDAP links--> xarray;
      to_level3 --> l3[\Level3 NetCDF or CSV/];
      to_dataframe --> csv[\Level2 CSV/];
      style query_opts fill:#ff0,stroke:#333,stroke-width:4px
      style userinputs fill:#fff,stroke:#000,stroke-width:1px
      style outputs fill:#fff,stroke:#000,stroke-width:1px
      style grid fill:#ff0,stroke:#333,stroke-width:4px
      style localpaths fill:#ff0,stroke:#333,stroke-width:4px
      style CMR fill:#ccc,stroke:#333,stroke-width:4px
      style cmaqsatproc fill:#cefad0,stroke:#cefad0,stroke-width:4px
      style csplabel fill:#cefad0,stroke:#cefad0,stroke-width:4px
  ```



  Henderson, B. H. (2022, October 17). cmaqsatproc v2: Satellite data processing for CMAQ [Poster]. 21st Annual Community Modeling and Analysis System Conference, Chapel Hill, NC. https://www.cmascenter.org/conference/2022/agenda.cfm; [direct link](https://www.cmascenter.org/conference/2022/slides/Henderson_satellite-data-CMAS2022.pdf)


pkgId: f56970dd23e65757ed95d295f8ad244f2eef3b59a4aa6854407283318c91a794
name: python-cmasher
arch: src
version: 1.8.0
epoch: 0
release: 1
summary: Scientific colormaps for making accessible, informative and 'cmashing' plots
url: https://cmasher.readthedocs.io
rpm_license: BSD-3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmasher-1.8.0-1.src.rpm
checksum_type: sha256
description:
  The *CMasher* package provides a collection of scientific colormaps and utility functions to be used by different *Python* packages and projects, mainly in combination with `matplotlib`_, showcased in the `online documentation`_ (where I also describe how to use the colormaps in other languages and applications).
  The colormaps in *CMasher* are all designed to be perceptually uniform sequential using the `viscm`_ package; most of them are color-vision deficiency friendly; and they cover a wide range of different color combinations to accommodate for most applications.
  It offers several alternatives to commonly used colormaps, like *chroma* and *rainforest* for *jet*; *sunburst* for *hot*; *neutral* for *binary*; and *fusion* and *redshift* for *coolwarm*.
  If you cannot find your ideal colormap, then please open an `issue`_, provide the colors and/or style you want, and I will try to create one to your liking!
  Let's get rid of all bad colormaps in the world together!
  *If you use CMasher for your work, then please star the repo, such that I can keep track of how many users it has and more easily raise awareness of bad colormaps.*
  *Additionally, if you use CMasher as part of your workflow in a scientific publication, please consider citing the CMasher paper* (*BibTeX:* ``cmr.get_bibtex``).


pkgId: 3e9c49d147b71f267f98387fa8d585477abdf11f16ea6c4a2a9d7ba1cdb1b52c
name: python-cmbagent-autogen
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: Enabling Next-Gen LLM Applications via Multi-Agent Conversation Framework -- by cosmologists
url: https://github.com/CMBAgents/autogen
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmbagent-autogen-0.0.1-1.src.rpm
checksum_type: sha256
description:
  <a name="readme-top"></a>


  <div align="center">

  <img src="https://microsoft.github.io/autogen/img/ag.svg" alt="AutoGen Logo" width="100">


  [![PyPI version](https://badge.fury.io/py/pyautogen.svg)](https://badge.fury.io/py/pyautogen)
  [![Build](https://github.com/microsoft/autogen/actions/workflows/python-package.yml/badge.svg)](https://github.com/microsoft/autogen/actions/workflows/python-package.yml)
  ![Python Version](https://img.shields.io/badge/3.8%20%7C%203.9%20%7C%203.10%20%7C%203.11%20%7C%203.12-blue)
  [![Downloads](https://static.pepy.tech/badge/pyautogen/week)](https://pepy.tech/project/pyautogen)

  [![NuGet version](https://badge.fury.io/nu/AutoGen.Core.svg)](https://badge.fury.io/nu/AutoGen.Core)


  [![Discord](https://img.shields.io/discord/1153072414184452236?logo=discord&style=flat)](https://aka.ms/autogen-dc)
  [![Twitter](https://img.shields.io/twitter/url/https/twitter.com/cloudposse.svg?style=social&label=Follow%20%40pyautogen)](https://twitter.com/pyautogen)

  </div>






  AutoGen is an open-source programming framework for building AI agents and facilitating cooperation among multiple agents to solve tasks. AutoGen aims to streamline the development and research of agentic AI, much like PyTorch does for Deep Learning. It offers features such as agents capable of interacting with each other, facilitates the use of various large language models (LLMs) and tool use support, autonomous and human-in-the-loop workflows, and multi-agent conversation patterns.

  > [!IMPORTANT]
  > *Note for contributors and users*</b>: [microsoft/autogen](https://aka.ms/autogen-gh) is the official repository of AutoGen project and it is under active development and maintenance under MIT license. We welcome contributions from developers and organizations worldwide. Our goal is to foster a collaborative and inclusive community where diverse perspectives and expertise can drive innovation and enhance the project's capabilities. We acknowledge the invaluable contributions from our existing contributors, as listed in [contributors.md](./CONTRIBUTORS.md). Whether you are an individual contributor or represent an organization, we invite you to join us in shaping the future of this project. For further information please also see [Microsoft open-source contributing guidelines](https://github.com/microsoft/autogen?tab=readme-ov-file#contributing).
  >
  > -_Maintainers (Sept 6th, 2024)_


  ![AutoGen Overview](https://github.com/microsoft/autogen/blob/main/website/static/img/autogen_agentchat.png)

  - AutoGen enables building next-gen LLM applications based on [multi-agent conversations](https://microsoft.github.io/autogen/docs/Use-Cases/agent_chat) with minimal effort. It simplifies the orchestration, automation, and optimization of a complex LLM workflow. It maximizes the performance of LLM models and overcomes their weaknesses.
  - It supports [diverse conversation patterns](https://microsoft.github.io/autogen/docs/Use-Cases/agent_chat#supporting-diverse-conversation-patterns) for complex workflows. With customizable and conversable agents, developers can use AutoGen to build a wide range of conversation patterns concerning conversation autonomy,
    the number of agents, and agent conversation topology.
  - It provides a collection of working systems with different complexities. These systems span a [wide range of applications](https://microsoft.github.io/autogen/docs/Use-Cases/agent_chat#diverse-applications-implemented-with-autogen) from various domains and complexities. This demonstrates how AutoGen can easily support diverse conversation patterns.
  - AutoGen provides [enhanced LLM inference](https://microsoft.github.io/autogen/docs/Use-Cases/enhanced_inference#api-unification). It offers utilities like API unification and caching, and advanced usage patterns, such as error handling, multi-config inference, context programming, etc.

  AutoGen was created out of collaborative [research](https://microsoft.github.io/autogen/docs/Research) from Microsoft, Penn State University, and the University of Washington.

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>




  <details>

  <summary>Expand</summary>

  :fire: June 6, 2024: WIRED publishes a new article on AutoGen: [Chatbot Teamwork Makes the AI Dream Work](https://www.wired.com/story/chatbot-teamwork-makes-the-ai-dream-work/) based on interview with [Adam Fourney](https://github.com/afourney).

  :fire: June 4th, 2024: Microsoft Research Forum publishes new update and video on [AutoGen and Complex Tasks](https://www.microsoft.com/en-us/research/video/autogen-update-complex-tasks-and-agents/) presented by [Adam Fourney](https://github.com/afourney).

  :fire: May 29, 2024: DeepLearning.ai launched a new short course [AI Agentic Design Patterns with AutoGen](https://www.deeplearning.ai/short-courses/ai-agentic-design-patterns-with-autogen), made in collaboration with Microsoft and Penn State University, and taught by AutoGen creators [Chi Wang](https://github.com/sonichi) and [Qingyun Wu](https://github.com/qingyun-wu).

  :fire: May 24, 2024: Foundation Capital published an article on [Forbes: The Promise of Multi-Agent AI](https://www.forbes.com/sites/joannechen/2024/05/24/the-promise-of-multi-agent-ai/?sh=2c1e4f454d97) and a video [AI in the Real World Episode 2: Exploring Multi-Agent AI and AutoGen with Chi Wang](https://www.youtube.com/watch?v=RLwyXRVvlNk).

  :fire: May 13, 2024: [The Economist](https://www.economist.com/science-and-technology/2024/05/13/todays-ai-models-are-impressive-teams-of-them-will-be-formidable) published an article about multi-agent systems (MAS) following a January 2024 interview with [Chi Wang](https://github.com/sonichi).

  :fire: May 11, 2024: [AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation](https://openreview.net/pdf?id=uAjxFFing2) received the best paper award at the [ICLR 2024 LLM Agents Workshop](https://llmagents.github.io/).

  :fire: Apr 26, 2024: [AutoGen.NET](https://microsoft.github.io/autogen-for-net/) is available for .NET developers! Thanks [XiaoYun Zhang](https://www.linkedin.com/in/xiaoyun-zhang-1b531013a/)

  :fire: Apr 17, 2024: Andrew Ng cited AutoGen in [The Batch newsletter](https://www.deeplearning.ai/the-batch/issue-245/) and [What's next for AI agentic workflows](https://youtu.be/sal78ACtGTc?si=JduUzN_1kDnMq0vF) at Sequoia Capital's AI Ascent (Mar 26).

  :fire: Mar 3, 2024: What's new in AutoGen? 📰[Blog](https://microsoft.github.io/autogen/blog/2024/03/03/AutoGen-Update); 📺[Youtube](https://www.youtube.com/watch?v=j_mtwQiaLGU).

  :fire: Mar 1, 2024: the first AutoGen multi-agent experiment on the challenging [GAIA](https://huggingface.co/spaces/gaia-benchmark/leaderboard) benchmark achieved the No. 1 accuracy in all the three levels.

  <!-- :tada: Jan 30, 2024: AutoGen is highlighted by Peter Lee in Microsoft Research Forum [Keynote](https://t.co/nUBSjPDjqD). -->

  :tada: Dec 31, 2023: [AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation Framework](https://arxiv.org/abs/2308.08155) is selected by [TheSequence: My Five Favorite AI Papers of 2023](https://thesequence.substack.com/p/my-five-favorite-ai-papers-of-2023).

  <!-- :fire: Nov 24: pyautogen [v0.2](https://github.com/microsoft/autogen/releases/tag/v0.2.0) is released with many updates and new features compared to v0.1.1. It switches to using openai-python v1. Please read the [migration guide](https://microsoft.github.io/autogen/docs/Installation#python). -->

  <!-- :fire: Nov 11: OpenAI's Assistants are available in AutoGen and interoperatable with other AutoGen agents! Checkout our [blogpost](https://microsoft.github.io/autogen/blog/2023/11/13/OAI-assistants) for details and examples. -->

  :tada: Nov 8, 2023: AutoGen is selected into [Open100: Top 100 Open Source achievements](https://www.benchcouncil.org/evaluation/opencs/annual.html) 35 days after spinoff from [FLAML](https://github.com/microsoft/FLAML).

  <!-- :tada: Nov 6, 2023: AutoGen is mentioned by Satya Nadella in a [fireside chat](https://youtu.be/0pLBvgYtv6U). -->

  <!-- :tada: Nov 1, 2023: AutoGen is the top trending repo on GitHub in October 2023. -->

  <!-- :tada: Oct 03, 2023: AutoGen spins off from [FLAML](https://github.com/microsoft/FLAML) on GitHub. -->

  <!-- :tada: Aug 16: Paper about AutoGen on [arxiv](https://arxiv.org/abs/2308.08155). -->

  :tada: Mar 29, 2023: AutoGen is first created in [FLAML](https://github.com/microsoft/FLAML).

  <!--
  :fire: FLAML is highlighted in OpenAI's [cookbook](https://github.com/openai/openai-cookbook#related-resources-from-around-the-web).

  :fire: [autogen](https://microsoft.github.io/autogen/) is released with support for ChatGPT and GPT-4, based on [Cost-Effective Hyperparameter Optimization for Large Language Model Generation Inference](https://arxiv.org/abs/2303.04673).

  :fire: FLAML supports Code-First AutoML & Tuning – Private Preview in [Microsoft Fabric Data Science](https://learn.microsoft.com/en-us/fabric/data-science/). -->

  </details>



  To see what we are working on and what we plan to work on, please check our
  [Roadmap Issues](https://aka.ms/autogen-roadmap).

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>


  The easiest way to start playing is
  1. Click below to use the GitHub Codespace

      [![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/microsoft/autogen?quickstart=1)

   2. Copy OAI_CONFIG_LIST_sample to ./notebook folder, name to OAI_CONFIG_LIST, and set the correct configuration.
   3. Start playing with the notebooks!

  *NOTE*: OAI_CONFIG_LIST_sample lists GPT-4 as the default model, as this represents our current recommendation, and is known to work well with AutoGen. If you use a model other than GPT-4, you may need to revise various system prompts (especially if using weaker models like GPT-3.5-turbo). Moreover, if you use models other than those hosted by OpenAI or Azure, you may incur additional risks related to alignment and safety. Proceed with caution if updating this default.

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>




  Find detailed instructions for users [here](https://microsoft.github.io/autogen/docs/installation/Docker#step-1-install-docker), and for developers [here](https://microsoft.github.io/autogen/docs/Contribute#docker-for-development).



  AutoGen requires **Python version >= 3.8, < 3.13**. It can be installed from pip:

  ```bash
  pip install pyautogen
  ```

  Minimal dependencies are installed without extra options. You can install extra options based on the feature you need.

  <!-- For example, use the following to install the dependencies needed by the [`blendsearch`](https://microsoft.github.io/FLAML/docs/Use-Cases/Tune-User-Defined-Function#blendsearch-economical-hyperparameter-optimization-with-blended-search-strategy) option.
  ```bash
  pip install "pyautogen[blendsearch]"
  ``` -->

  Find more options in [Installation](https://microsoft.github.io/autogen/docs/Installation#option-2-install-autogen-locally-using-virtual-environment).

  <!-- Each of the [`notebook examples`](https://github.com/microsoft/autogen/tree/main/notebook) may require a specific option to be installed. -->

  Even if you are installing and running AutoGen locally outside of docker, the recommendation and default behavior of agents is to perform [code execution](https://microsoft.github.io/autogen/docs/FAQ/#code-execution) in docker. Find more instructions and how to change the default behaviour [here](https://microsoft.github.io/autogen/docs/Installation#code-execution-with-docker-(default)).

  For LLM inference configurations, check the [FAQs](https://microsoft.github.io/autogen/docs/FAQ#set-your-api-endpoints).

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>



  Autogen enables the next-gen LLM applications with a generic [multi-agent conversation](https://microsoft.github.io/autogen/docs/Use-Cases/agent_chat) framework. It offers customizable and conversable agents that integrate LLMs, tools, and humans.
  By automating chat among multiple capable agents, one can easily make them collectively perform tasks autonomously or with human feedback, including tasks that require using tools via code.

  Features of this use case include:

  - **Multi-agent conversations**: AutoGen agents can communicate with each other to solve tasks. This allows for more complex and sophisticated applications than would be possible with a single LLM.
  - **Customization**: AutoGen agents can be customized to meet the specific needs of an application. This includes the ability to choose the LLMs to use, the types of human input to allow, and the tools to employ.
  - **Human participation**: AutoGen seamlessly allows human participation. This means that humans can provide input and feedback to the agents as needed.

  For [example](https://github.com/microsoft/autogen/blob/main/test/twoagent.py),

  ```python
  from autogen import AssistantAgent, UserProxyAgent, config_list_from_json



  config_list = config_list_from_json(env_or_file="OAI_CONFIG_LIST")

  assistant = AssistantAgent("assistant", llm_config={"config_list": config_list})
  user_proxy = UserProxyAgent("user_proxy", code_execution_config={"work_dir": "coding", "use_docker": False}) # IMPORTANT: set to True to run code in docker, recommended
  user_proxy.initiate_chat(assistant, message="Plot a chart of NVDA and TESLA stock price change YTD.")

  ```

  This example can be run with

  ```python
  python test/twoagent.py
  ```

  After the repo is cloned.
  The figure below shows an example conversation flow with AutoGen.
  ![Agent Chat Example](https://github.com/microsoft/autogen/blob/main/website/static/img/chat_example.png)

  Alternatively, the [sample code](https://github.com/microsoft/autogen/blob/main/samples/simple_chat.py) here allows a user to chat with an AutoGen agent in ChatGPT style.
  Please find more [code examples](https://microsoft.github.io/autogen/docs/Examples#automated-multi-agent-chat) for this feature.

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>



  Autogen also helps maximize the utility out of the expensive LLMs such as ChatGPT and GPT-4. It offers [enhanced LLM inference](https://microsoft.github.io/autogen/docs/Use-Cases/enhanced_inference#api-unification) with powerful functionalities like caching, error handling, multi-config inference and templating.

  <!-- For example, you can optimize generations by LLM with your own tuning data, success metrics, and budgets.

  ```python

  config, analysis = autogen.Completion.tune(
      data=tune_data,
      metric="success",
      mode="max",
      eval_func=eval_func,
      inference_budget=0.05,
      optimization_budget=3,
      num_samples=-1,
  )

  response = autogen.Completion.create(context=test_instance, **config)
  ```

  Please find more [code examples](https://microsoft.github.io/autogen/docs/Examples#tune-gpt-models) for this feature. -->

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>



  You can find detailed documentation about AutoGen [here](https://microsoft.github.io/autogen/).

  In addition, you can find:

  - [Research](https://microsoft.github.io/autogen/docs/Research), [blogposts](https://microsoft.github.io/autogen/blog) around AutoGen, and [Transparency FAQs](https://github.com/microsoft/autogen/blob/main/TRANSPARENCY_FAQS.md)

  - [Discord](https://aka.ms/autogen-dc)

  - [Contributing guide](https://microsoft.github.io/autogen/docs/Contribute)

  - [Roadmap](https://github.com/orgs/microsoft/projects/989/views/3)

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>



  [AutoGen Studio](https://www.microsoft.com/en-us/research/publication/autogen-studio-a-no-code-developer-tool-for-building-and-debugging-multi-agent-systems/)

  ```
  @inproceedings{dibia2024studio,
        title={AutoGen Studio: A No-Code Developer Tool for Building and Debugging Multi-Agent Systems},
        author={Victor Dibia and Jingya Chen and Gagan Bansal and Suff Syed and Adam Fourney and Erkang (Eric) Zhu and Chi Wang and Saleema Amershi},
        year={2024},
        booktitle={Pre-Print}
  }
  ```

  [AutoGen](https://aka.ms/autogen-pdf)

  ```
  @inproceedings{wu2023autogen,
        title={AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation Framework},
        author={Qingyun Wu and Gagan Bansal and Jieyu Zhang and Yiran Wu and Beibin Li and Erkang Zhu and Li Jiang and Xiaoyun Zhang and Shaokun Zhang and Jiale Liu and Ahmed Hassan Awadallah and Ryen W White and Doug Burger and Chi Wang},
        year={2024},
        booktitle={COLM},
  }
  ```

  [EcoOptiGen](https://arxiv.org/abs/2303.04673)

  ```
  @inproceedings{wang2023EcoOptiGen,
      title={Cost-Effective Hyperparameter Optimization for Large Language Model Generation Inference},
      author={Chi Wang and Susan Xueqing Liu and Ahmed H. Awadallah},
      year={2023},
      booktitle={AutoML'23},
  }
  ```

  [MathChat](https://arxiv.org/abs/2306.01337)

  ```
  @inproceedings{wu2023empirical,
      title={An Empirical Study on Challenging Math Problem Solving with GPT-4},
      author={Yiran Wu and Feiran Jia and Shaokun Zhang and Hangyu Li and Erkang Zhu and Yue Wang and Yin Tat Lee and Richard Peng and Qingyun Wu and Chi Wang},
      year={2023},
      booktitle={ArXiv preprint arXiv:2306.01337},
  }
  ```

  [AgentOptimizer](https://arxiv.org/pdf/2402.11359)

  ```
  @article{zhang2024training,
    title={Training Language Model Agents without Modifying Language Models},
    author={Zhang, Shaokun and Zhang, Jieyu and Liu, Jiale and Song, Linxin and Wang, Chi and Krishna, Ranjay and Wu, Qingyun},
    journal={ICML'24},
    year={2024}
  }
  ```

  [StateFlow](https://arxiv.org/abs/2403.11322)
  ```
  @article{wu2024stateflow,
    title={StateFlow: Enhancing LLM Task-Solving through State-Driven Workflows},
    author={Wu, Yiran and Yue, Tianwei and Zhang, Shaokun and Wang, Chi and Wu, Qingyun},
    journal={arXiv preprint arXiv:2403.11322},
    year={2024}
  }
  ```

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>



  This project welcomes contributions and suggestions. Most contributions require you to agree to a
  Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us
  the rights to use your contribution. For details, visit <https://cla.opensource.microsoft.com>.

  If you are new to GitHub, [here](https://opensource.guide/how-to-contribute/#how-to-submit-a-contribution) is a detailed help source on getting involved with development on GitHub.

  When you submit a pull request, a CLA bot will automatically determine whether you need to provide
  a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions
  provided by the bot. You will only need to do this once across all repos using our CLA.

  This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
  For more information, see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or
  contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>


  <a href="https://github.com/microsoft/autogen/graphs/contributors">
    <img src="https://contrib.rocks/image?repo=microsoft/autogen&max=204" />
  </a>

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>



  Microsoft and any contributors grant you a license to the Microsoft documentation and other content
  in this repository under the [Creative Commons Attribution 4.0 International Public License](https://creativecommons.org/licenses/by/4.0/legalcode),
  see the [LICENSE](LICENSE) file, and grant you a license to any code in the repository under the [MIT License](https://opensource.org/licenses/MIT), see the
  [LICENSE-CODE](LICENSE-CODE) file.

  Microsoft, Windows, Microsoft Azure, and/or other Microsoft products and services referenced in the documentation
  may be either trademarks or registered trademarks of Microsoft in the United States and/or other countries.
  The licenses for this project do not grant you rights to use any Microsoft names, logos, or trademarks.
  Microsoft's general trademark guidelines can be found at http://go.microsoft.com/fwlink/?LinkID=254653.

  Privacy information can be found at https://go.microsoft.com/fwlink/?LinkId=521839

  Microsoft and any contributors reserve all other rights, whether under their respective copyrights, patents,
  or trademarks, whether by implication, estoppel, or otherwise.

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>


pkgId: 33c1ff9475b47ce376930f6b384438f5bbce3366b3d4579b66ce151f44192b05
name: python-cmcrameri
arch: src
version: 1.9
epoch: 0
release: 1
summary: Perceptually uniform colormaps by Fabio Crameri
url: https://pypi.org/project/cmcrameri/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmcrameri-1.9-1.src.rpm
checksum_type: sha256
description:
  [![Project Status: Active – The project has reached a stable, usable state and is being actively developed.](https://www.repostatus.org/badges/latest/active.svg)](https://www.repostatus.org/#active)

  ![python versions](https://img.shields.io/pypi/pyversions/cmcrameri.svg)

  ![pypi](https://badge.fury.io/py/cmcrameri.svg) [![Downloads](https://pepy.tech/badge/cmcrameri)](https://pepy.tech/project/cmcrameri)

  ![anaconda badge](https://anaconda.org/conda-forge/cmcrameri/badges/version.svg) [![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/cmcrameri.svg)](https://anaconda.org/conda-forge/cmcrameri)


  This is a Python wrapper around Fabio Crameri's perceptually uniform colormaps.

  <https://www.fabiocrameri.ch/colourmaps/>

  All credit for creating the colormaps to Fabio.
  Any errors in the Python implementation of colormaps are my own.

  This version is based on _Scientific colour maps_ [version 8.0](https://doi.org/10.5281/zenodo.8035877) (2023-06-14).



  With `pip`:

  ```sh
  python -m pip install cmcrameri
  ```

  With `conda`:

  ```sh
  conda install -c conda-forge cmcrameri
  ```



  ```python
  import cmcrameri.cm as cmc
  import matplotlib.pyplot as plt
  import numpy as np

  x = np.linspace(0, 1, 100)[np.newaxis, :]

  plt.imshow(x, aspect='auto', cmap=cmc.batlow)
  plt.axis('off')
  plt.show()
  ```

  Alternatively, the registered name string can be used.

  ```python
  import cmcrameri # required in order to register the colormaps with Matplotlib
  ...
  plt.imshow(x, aspect='auto', cmap='cmc.batlow')
  ```



  You can access all the core colormaps from Fabio Crameri's list by `cmcrameri.cm.<colormapname>`.

  You can use tab autocompletion on `cmcrameri.cm` if your editor supports it.

  For a reversed colormap, append `_r` to the colormap name.

  Categorical colormaps have the suffix `S`.

  For an image of all the available colormaps without leaving the comfort of your Python session:

  ```python
  from cmcrameri import show_cmaps

  show_cmaps()
  ```

  ![Figure demonstrating the colormaps](cmcrameri/colormaps.png)

  The original colormap text files are shipped as part of the package.
  Find them on your system with:

  ```python
  from cmcrameri.cm import paths

  paths
  ```



  This work is licensed under an [MIT license](https://mit-license.org/).

rpm_license:
  MIT License  Colormaps in cmcrameri/cm/cmaps: Copyright (c) 2020 Fabio Crameri  Python scripts and packaging: Copyright (c) 2020 Callum Rollo  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: ea7001ed30891b6f4d38821c4528b206bedeb35e2af18e178f3b53a1042c455e
name: python-cmd-queue
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: The cmd_queue module for a DAG of bash commands
url: https://gitlab.kitware.com/computer-vision/cmd_queue
rpm_license: Apache 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmd-queue-0.2.1-1.src.rpm
checksum_type: sha256
description:
  |Pypi| |Downloads| |GitlabCIPipeline| |GitlabCICoverage| |ReadTheDocs|
  +------------------+-------------------------------------------------------------------------------------+
  | Read the docs    | https://cmd-queue.readthedocs.io                                                    |
  +------------------+-------------------------------------------------------------------------------------+
  | Gitlab           | https://gitlab.kitware.com/computer-vision/cmd_queue                                |
  +------------------+-------------------------------------------------------------------------------------+
  | Pypi             | https://pypi.org/project/cmd_queue                                                  |
  +------------------+-------------------------------------------------------------------------------------+
  | Slides           | https://docs.google.com/presentation/d/1BjJkjMx6bxu1uek-hAGpwj760u9rraVn7st8J5OsZME |
  +------------------+-------------------------------------------------------------------------------------+
  This is a simple module for "generating" a bash script that schedules multiples
  jobs (in parallel if possible) on a single machine. There are 3 backends with
  increasing levels of complexity: serial, tmux, and slurm.
  In serial mode, a single bash script gets written that executes your jobs in
  sequence. There are no external dependencies
  In tmux mode, multiple tmux sessions get opened and each of them executes your
  independent parts of your jobs. Dependencies are handled.
  In slurm mode, a real heavy-weight scheduling algorithm is used. In this mode
  we simply convert your jobs to slurm commands and execute them.
  Under the hood we build a DAG based on your specified dependencies and use this
  to appropriately order jobs.
  By default, bash scripts that would execute your jobs print to the console.
  This gives the user fine-grained control if they only want to run a subset of a
  pipeline manually. But if asked to run, cmd_queue will execute the bash jobs.
  Features
  ~~~~~~~~
  * Bash command scheduling
  * Execution is optional, can just print commands instead
  * No-parallelism always-available serial backend
  * Tmux based lightweight backend
  * Slurm based heavyweight backend
  * Python and Bash interface
  * Rich monitoring / live-control


pkgId: 58d13547a79a7a9339bca87ce89866dda44f4eed4fec6d5e5e6d3cc397d910d8
name: python-cmd2
arch: src
version: 2.4.3
epoch: 0
release: 1
summary: cmd2 - quickly build feature-rich and user-friendly interactive command line applications in Python
url: https://github.com/python-cmd2/cmd2
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmd2-2.4.3-1.src.rpm
checksum_type: sha256
description:
  ![system schema](https://raw.githubusercontent.com/python-cmd2/cmd2/master/.github/images/graph.drawio.png)
  When creating solutions developers have no shortage of tools to create rich and smart user interfaces.
  System administrators have long been duct taping together brittle workflows based on a menagerie of simple command line tools created by strangers on github and the guy down the hall.
  Unfortunately, when CLIs become significantly complex the ease of command discoverability tends to fade quickly.
  On the other hand, Web and traditional desktop GUIs are first in class when it comes to easily discovering functionality.
  The price we pay for beautifully colored displays is complexity required to aggregate disperate applications into larger systems.
  `cmd2` fills the niche between high [ease of command discovery](https://clig.dev/#ease-of-discovery) applications and smart workflow automation systems.
  The `cmd2` framework provides a great mixture of both worlds. Application designers can easily create complex applications and rely on the cmd2 library to offer effortless user facing help and extensive tab completion.
  When users become comfortable with functionality, cmd2 turns into a feature rich library enabling a smooth transition to full automation. If designed with enough forethought, a well implemented cmd2 application can serve as a boutique workflow tool. `cmd2` pulls off this flexibility based on two pillars of philosophy:
  * Tab Completion
  * Automation Transition


pkgId: 6f09abe19de79c526d4027667561267bbf832b269d0ccc31520453e8cd6e8914
name: python-cmd2
arch: src
version: 2.5.6
epoch: 0
release: 1
summary: cmd2 - quickly build feature-rich and user-friendly interactive command line applications in Python
url: https://pypi.org/project/cmd2/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmd2-2.5.6-1.src.rpm
checksum_type: sha256
description:
  ![system schema](https://raw.githubusercontent.com/python-cmd2/cmd2/master/.github/images/graph.drawio.png)
  When creating solutions developers have no shortage of tools to create rich and smart user interfaces.
  System administrators have long been duct taping together brittle workflows based on a menagerie of simple command line tools created by strangers on github and the guy down the hall.
  Unfortunately, when CLIs become significantly complex the ease of command discoverability tends to fade quickly.
  On the other hand, Web and traditional desktop GUIs are first in class when it comes to easily discovering functionality.
  The price we pay for beautifully colored displays is complexity required to aggregate disperate applications into larger systems.
  `cmd2` fills the niche between high [ease of command discovery](https://clig.dev/#ease-of-discovery) applications and smart workflow automation systems.
  The `cmd2` framework provides a great mixture of both worlds. Application designers can easily create complex applications and rely on the cmd2 library to offer effortless user facing help and extensive tab completion.
  When users become comfortable with functionality, cmd2 turns into a feature rich library enabling a smooth transition to full automation. If designed with enough forethought, a well implemented cmd2 application can serve as a boutique workflow tool. `cmd2` pulls off this flexibility based on two pillars of philosophy:
  * Tab Completion
  * Automation Transition

rpm_license:
  The MIT License (MIT)  Copyright (c) 2008-2024 Catherine Devlin and others  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: dd60f21b3bd3263ad551bd22abe117b9c92bbb0575742db69581e8c53504d4c4
name: python-cmd2-ext-test
arch: src
version: 2.0.0
epoch: 0
release: 1
url: https://github.com/python-cmd2/cmd2/tree/master/plugins/ext_test
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmd2-ext-test-2.0.0-1.src.rpm
checksum_type: sha256
summary:
  External test plugin for cmd2. Allows for external invocation of commands as if from a cmd2 pyscript

description:
  - [Overview](#overview)
  - [Example cmd2 Application](#example-cmd2-application)
  - [Defining the test fixture](#defining-the-test-fixture)
  - [Writing Tests](#writing-tests)
  - [License](#license)




  This plugin supports testing of a cmd2 application by exposing access cmd2 commands with the same context
  as from within a cmd2 pyscript.  This allows for verification of an application's support for pyscripts.




  The following short example shows how to mix in the external test plugin to create a fixture for testing
  your cmd2 application.

  Define your cmd2 application

  ```python
  import cmd2
  class ExampleApp(cmd2.Cmd):
      """An class to show how to use a plugin"""
      def __init__(self, *args, **kwargs):
          
          super().__init__(*args, **kwargs)

      def do_something(self, arg):
          self.last_result = 5
          self.poutput('this is the something command')
  ```



  In your test, define a fixture for your cmd2 application

  ```python
  import cmd2_ext_test
  import pytest

  class ExampleAppTester(cmd2_ext_test.ExternalTestMixin, ExampleApp):
      def __init__(self, *args, **kwargs):
          
          super().__init__(*args, **kwargs)

  @pytest.fixture
  def example_app():
      app = ExampleAppTester()
      app.fixture_setup()
      yield app
      app.fixture_teardown()

  ```



  Now write your tests that validate your application using the `app_cmd` function to access
  the cmd2 application's commands. This allows invocation of the application's commands in the
  same format as a user would type. The results from calling a command matches what is returned
  from running an python script with cmd2's pyscript command, which provides stdout, stderr, and
  the command's result data.

  ```python
  from cmd2 import CommandResult

  def test_something(example_app):
      
      out = example_app.app_cmd("something")

      
      assert isinstance(out, CommandResult)
      assert str(out.stdout).strip() == 'this is the something command'
      assert out.data == 5
  ```



  cmd2 [uses the very liberal MIT license](https://github.com/python-cmd2/cmd2/blob/master/LICENSE).
  We invite plugin authors to consider doing the same.


pkgId: b5207e9ccf45b0fce2a24dc11a0fe4f59821ddc391bc8ff8785f4bf190d0e2ee
name: python-cmd_gui_kit
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: cmd-gui-kit: A Python toolkit for enhanced CLI visualizations.
url: https://pypi.org/project/cmd_gui_kit/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmd_gui_kit-1.0.0-1.src.rpm
checksum_type: sha256
description:
  `cmd-gui-kit` is a Python toolkit for creating enhanced CLI visualizations, including progress bars, spinners, heatmaps, tables, and status indicators. It provides a flexible and modular interface for building visually appealing command-line applications.


  - **Progress Bars:** Dynamic, colored progress bars with percentage and elapsed time.
  - **Spinners:** Animated spinners for task progress.
  - **Heatmaps:** Visualize character frequencies or numerical data with a heatmap.
  - **ASCII Tables:** Create styled tables with custom headers and cell colors.
  - **Status Indicators:** Show success, error, warning, and info statuses with icons.
  - **Logging:** Real-time logs with levels (INFO, WARN, ERROR) and timestamps.



  You can install `cmd-gui-kit` via pip:

  ```bash
  pip install cmd-gui-kit
  ```




  ```python
  from cmd_gui_kit import CmdGUI
  gui = CmdGUI()
  ```


  ```python
  import time
  for i in range(101):
      gui.progress_bar(i, text="Processing...")
      time.sleep(0.05)
  ```


  ```python
  gui.spinner(duration=3, message="Loading...")
  ```


  ```python
  gui.heatmap("hello world")
  ```


  ```python
  data = [["Alice", 90], ["Bob", 85], ["Charlie", 95]]
  headers = ["Name", "Score"]
  gui.ascii_table(data, headers=headers)
  ```


  ```python
  gui.status("Operation completed successfully.", status="success")
  gui.status("An error occurred.", status="error")
  ```


  ```python
  gui.log("This is an informational message.", level="info")
  gui.log("This is a warning message.", level="warn")
  gui.log("This is an error message.", level="error")
  ```


  Contributions are welcome! Please fork the repository and submit a pull request.


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


  - **Author:** cagatay-softgineer
  - **Email:** cagatayalkan.b@gmail.com
  - **GitHub:** [https://github.com/cagatay-softgineer/cmd-gui-kit](https://github.com/cagatay-softgineer/cmd-gui-kit)


pkgId: a4fa6397495e0f59de2140ddcb50573753f3acd53c1bad6a629ba0afa4dc4318
name: python-cmdbench
arch: src
version: 0.1.22
epoch: 0
release: 1
summary: Quick and easy benchmarking for any command's CPU, memory, disk usage and runtime.
url: https://github.com/manzik/cmdbench
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmdbench-0.1.22-1.src.rpm
checksum_type: sha256
description:
  [![Deployment](https://github.com/manzik/cmdbench/actions/workflows/release.yml/badge.svg)](https://github.com/manzik/cmdbench/actions/workflows/release.yml)

  A quick and easy benchmarking tool for any command's CPU, memory and disk usage.
  CLI and the library functionalities are both provided.

  Note: This library is written in, heavily tested, and maintained for the **Linux** operating system primarily. But **Windows** and **macOS** are also supported. Create an issue in case you run into a problem.

  To install the library from PyPI, execute the following command in your terminal:
  ```bash
  pip install cmdbench
  ```
  Python compatibility: >=3.6

     * [Quick Start: Command Line Interface](#quick-start-command-line-interface)
     * [Quick Start: Library](#quick-start-library)
        * [Method 1: Easier](#method-1-easier)
        * [Method 2: More customizable](#method-2-more-customizable)
        * [Usage IPython Notebook](#usage-ipython-notebook)
     * [Documentation](#documentation)
        * [benchmark_command: method](#benchmark_commandcommand-str-iterations_num--1-raw_data--false)
        * [benchmark_command_generator: method](#benchmark_command_generatorcommand-str-interations_num--1-raw_data--false)
        * [BenchmarkResults: Class](#benchmarkresults-class)
        * [BenchmarkDict: Class](#benchmarkdict-classdefaultdict)
     * [Notes](#notes)
        * [macOS](#macos)
        * [Windows](#windows)


  You can use the CLI provided by the python package to benchmark any command.
  In the following demo, the command `node test.js` (a slightly modified version of [test.js](test.js)) is being benchmarked 10 times, average of resources are being printed and a plot for the command's cpu and memory usage is being saved to the file `plot.png`.

  [![Usage demo](https://github.com/manzik/cmdbench/raw/main/resources/cmdbench.svg?sanitize=true)](https://asciinema.org/a/25Juo57eeSrNVJPa7rJiokW78)

  The output plot file `plot.png` for the demo will look like:

  ![Resources plot](https://github.com/manzik/cmdbench/raw/main/resources/plot.png)




  You can simply use the `benchmark_command` function to benchmark a command.
  Benchmarks the command `stress --cpu 10 --timeout 5` over 20 iterations. But prints only the first one from the benchmark results.
  ```python
  >>> import cmdbench
  >>> benchmark_results = cmdbench.benchmark_command("stress --cpu 10 --timeout 5", iterations_num = 20)
  >>> first_iteration_result = benchmark_results.get_first_iteration()
  >>> first_iteration_result
  {
    'cpu': {
      'system_time': 0.04,
      'total_time': 49.75,
      'user_time': 49.71,
    },
    'disk': {
      'read_bytes': 0,
      'read_chars': 5124,
      'total_bytes': 0,
      'total_chars': 5243,
      'write_bytes': 0,
      'write_chars': 119,
    },
    'memory': {
      'max': 2166784,
      'max_perprocess': 1060864,
    },
    'process': {
      'execution_time': 5.0,
      'stderr_data': '',
      'stdout_data': 'stress: info: [20773] dispatching hogs: 10 cpu, 0 io, 0 vm, 0 hdd\n\nstress: info: [20773] successful run
                      completed in 5s\n',
    },
    'time_series': {
      'cpu_percentages': array([  0. ,   0. , 824.1, ..., 889. , 998.3,   0. ])
      'memory_bytes': array([2166784, 2166784, 2166784, ..., 2166784, 2166784, 1060864])
      'sample_milliseconds': array([  39,   54,   65, ..., 4979, 4988, 4997])
    },
  }
  >>> first_iteration_result.process.execution_time
  5.0
  ```

  You can also create one or more BenchmarkResults objects, and add benchmark results to them over time.
  So you are not forced to perform the benchmarking for the command consecutively when you simply can't.
  Could be helpful when you are trying to benchmark multiple commands that need to be executed in a certain order consecutively or depend on each other.
  ```python
  >>> from cmdbench import benchmark_command, BenchmarkResults
  >>> benchmark_results = BenchmarkResults()
  >>> for _ in range(20):
  ...   new_benchmark_result = cmdbench.benchmark_command("stress --cpu 10 --timeout 5")
  ...   benchmark_results.add_benchmark_result(new_benchmark_result)
  ... # The for loop above is equivalent to: benchmark_results = cmdbench.benchmark_command("stress --cpu 10 --timeout 5", iterations_num = 20)
  >>> benchmark_results.get_averages()
  {
    'cpu': {
      'system_time': 0.012500000000000002,
      'total_time': 48.468,
      'user_time': 48.45550000000001,
    },
    'disk': {
      'read_bytes': 0.0,
      'read_chars': 5124.0,
      'total_bytes': 0.0,
      'total_chars': 5232.4,
      'write_bytes': 0.0,
      'write_chars': 108.4,
    },
    'memory': {
      'max': 2094080.0,
      'max_perprocess': 1020928.0,
    },
    'process': {
      'execution_time': 5.0,
      'stderr_data': None,
      'stdout_data': None,
    },
    'time_series': {
      'cpu_percentages': array([  0.        , 476.03157895, 794.66363636, ..., 976.05555556,
         188.97777778,   0.        ])
      'memory_bytes': array([2093924.84848485, 2096074.10526316, 2099013.81818182, ...,
         2090552.88888889, 1256561.77777778,  810188.8       ])
      'sample_milliseconds': array([  11.42424242,   21.73684211,   30.90909091, ..., 4986.44444444,
         4995.05555556, 5000.2       ])
    },
  }
  ```

  For a more comprehensive demonstration on how to use the library and the resources plot, check the provided [ipython notebook](benchmark-usage.ipynb).




    - Arguments
      - command: Target command to process.
      - iterations_num: Number of times to measure the program's resources.
      - raw_data: Whether or not to show all different info from different sources like psutil and GNU Time (if available).
    - Returns a BenchmarkResults object containing the related results.


    - Arguments: Same as benchmark_command
    - Returns a [generator](https://wiki.python.org/moin/Generators) object allowing you to obtain a BenchmarkResults after each iteration of benchmarking until done (useful for monitoring the progress and recieving benchmarking data on the go).


    - Methods:
      - `get_first_iteration()`
        Returns the first iteration result in the benchmark results object.
      - `get_iterations()`
        Returns the result for all of the iterations in the benchmark results object.
      - `get_values_per_attribute()`
        Returns object containing lists for each type of value over different iterations.
      - `get_averages()`
        Returns the average for all types of value over different iterations. Also calculates the average of the time series data.
      - `get_statistics()`
        Returns different statistics (mean, stdev, min, max) for all types of values over different iterations.
      - `get_resources_plot(width: int, height: int)`
        Returns matplotlib figure object of CPU and Memory usage of target process over time which can be viewed in an ipython notebook or be saved to an image file.
      - `add_benchmark_result(adding_result: BenchmarkResults)`
        Adds another BenchmarkResults object's benchmark results iterations' data to the current object.


    A custom internal dictionary class used to represent the data for an iteration.
    Data inside objects from this class are accessible through both dot notation `obj.key` and key access `obj["key"]`




  When benchmarking on windows, you will need to wrap your main code around the `if __name__ == '__main__':` statement.


  MacOS does not allow process-specific disk usage information collection, therefore disk usage will not be reported on macOS when you perform benchmarking.


pkgId: 2ce5a5edf75044a0d96c159fc57ead53b2cecbd4850dbda5c8e7b79a350fa455
name: python-cmdbox
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: cmdbox: An application that executes AI model files in onnx or mmlab format.
url: https://github.com/hamacom2004jp/cmdbox
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmdbox-0.1.0-1.src.rpm
checksum_type: sha256
description:
  - プラグイン機構を備えたコマンドラインアプリケーションです。
  - ドキュメントは[こちら](https://hamacom2004jp.github.io/cmdbox/)。
  - cmdboxを使用することで、複雑なオプションを持つコマンドを簡単に実装できます。
  - 実装したコマンドは、RESTAPIとしても呼び出せるようになります。
  - 実装したコマンドは、redisを介してリモートサーバーで実行することが出来ます。
  - 実装したコマンドは、Webコンソールから実行できます。
  - リモートサーバーでコマンドを実行するために、必要なファイルをwebファイラーを使って転送できます。




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


pkgId: 09924a53a4e203721b8866bcebea8474494414ba35b8c117524a17d1089cf8f8
name: python-cmdbroker
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: Broker commands to a server
url: https://pypi.org/project/cmdbroker/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmdbroker-0.0.4-1.src.rpm
checksum_type: sha256
description:
  Command Broker
  _________________

  [![PyPI version](https://badge.fury.io/py/cmdbroker.svg)](http://badge.fury.io/py/cmdbroker)
  [![Test Status](https://github.com/brad/cmdbroker/workflows/Test/badge.svg?branch=develop)](https://github.com/brad/cmdbroker/actions?query=workflow%3ATest)
  [![Lint Status](https://github.com/brad/cmdbroker/workflows/Lint/badge.svg?branch=develop)](https://github.com/brad/cmdbroker/actions?query=workflow%3ALint)
  [![codecov](https://codecov.io/gh/brad/cmdbroker/branch/main/graph/badge.svg)](https://codecov.io/gh/brad/cmdbroker)
  [![Join the chat at https://gitter.im/brad/cmdbroker](https://badges.gitter.im/brad/cmdbroker.svg)](https://gitter.im/brad/cmdbroker?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
  [![License](https://img.shields.io/github/license/mashape/apistatus.svg)](https://pypi.python.org/pypi/cmdbroker/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  _________________

  [Read Latest Documentation](https://brad.github.io/cmdbroker/) - [Browse GitHub Code Repository](https://github.com/brad/cmdbroker/)
  _________________

  **cmdbroker** Broker commands to a server



  Command Broker (cmdbroker) is a tool that allows a client to send commands to a server and get the results back. While for most use cases you can simply run commands over SSH, cmdbroker is designed for scenarios where you need to run commands with access to the server's UI. This can be particularly useful for commands that require graphical interfaces or other UI elements that are not accessible through standard SSH sessions.



  - **Client-Server Architecture**: cmdbroker uses a client-server model to facilitate command execution and result retrieval.
  - **SSL Encryption**: All communications between the client and server are secured using SSL, ensuring that data is encrypted and protected from eavesdropping.
  - **UI Access**: Enables running commands that require access to the server's UI, which is not possible with standard SSH.
  - **Easy Integration**: Simple to integrate into existing workflows and systems.



  You can install cmdbroker using pip:

  ```bash
  pip install cmdbroker
  ```





  ```bash
  cmdbroker --server
  ```

  This will walk you through generating an SSL certificate and then start the server. Protect the generated key with `chmod 600 broker-key.pem`. Copy the generated `broker-cert.pem` file to your client machine (after copying, protect it with a similar `chmod`) and follow the instructions for the client



  ```bash
  cmdbroker 'echo "Hello, World!"'
  ```

  The following happens when you do this:
  - The client makes a secure connection to the server
  - The client sends the command to the server over this connection
  - The server component runs `echo "Hello, World!"`
  - The server component takes the output from that command and returns it to the client
  - The client outputs the results on stdout

  You may also redirect stdin and use it in the server-side command, ex:

  ```bash
  echo "Hello, World\!" | cmdbroker cat
  ```


pkgId: 46c69a78925f987cbddb0432c5be371b4418afbed55fdb498f430c505117a7df
name: python-cmdcheatsheet
arch: src
version: 0.0.48
epoch: 0
release: 1
summary: Terminal commands cheat sheet helper
url: https://github.com/obaranovskyi/cmdcheatsheet
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmdcheatsheet-0.0.48-1.src.rpm
checksum_type: sha256
description:
  ```
                      _      _                _       _               _
    ___ _ __ ___   __| | ___| |__   ___  __ _| |_ ___| |__   ___  ___| |_
   / __| '_ ` _ \ / _` |/ __| '_ \ / _ \/ _` | __/ __| '_ \ / _ \/ _ \ __|
  | (__| | | | | | (_| | (__| | | |  __/ (_| | |_\__ \ | | |  __/  __/ |_
   \___|_| |_| |_|\__,_|\___|_| |_|\___|\__,_|\__|___/_| |_|\___|\___|\__|
  ```
  Is a terminal command tool 🖥 that helps to store commands you don't want to keep in the head 🧠

  ![](./images/base-usage.png)


  ```bash
  cmdcheatsheet -h
  ```
  or:
  ```bash
  cmdcheatsheet --help
  ```
  here is the output:
  ```
    --commands, -c - Display all commands.
    --commands-info, -ci - Display all commands, including all details such as ids, etc., all commands.
    --commands-table, -ct - Display all commands using a table view.
    --add <command> <description>, -a <command> <description> - Add new command to the list.
    --update <id> <name> <description>, -u <id> <name> <description> - Update a <command> by id.
    --delete <id>, -d <id> - Delete a <command> by id.
    --find <command>, -f <command> - Search for a command.
    --find-info <command>, -fi <command> - Search for a command and include all details, such as ids, etc.
    --global-find <command>, -gf <command> - Global search.
    --detailed-global-find <command>, -gfi <command> - Search globally for a command and include all details, such as ids, etc.
    --find-table <command>, -ft <command> - Search for a command and show it using a table view.
    --available-command-names <number_of_columns:optional>, -acn <number_of_columns:optional> - Show all stored command names.
    --version, -v - Display version.
    --help, -h - Show a program help notes.
    --display-available-configs, -dac - Display available configurations.
    --display-configs <key:optional>, -dc <key:optional> - Display configurations.
    --remove-config <key>, -rc <key> - Remove a config.
    --set-config <key> <value>, -sc <key> <value> - Set config.
    --set-config-to-default, -sctd - Set the configuration to default.
    --set-single-config-to-default <key>, -ssctd <key> - Set a single configuration to default.
    --add-alternative-store <store_name> <store_location>, -aas <store_name> <store_location> - Add alternative commands store (JSON file) location.
    --delete-alternative-store <store_name>, -das <store_name> - Delete alternative commands store (JSON file).
    --display-applied-alternative-store-name, -daasn - Display the name of applied alternative store.
    --display-available-alternative-stores, -daas - Display available alternative stores.
    --switch-to-alternative-store <store_name>, -stas <store_name> - Switch to alternative store location.
    --update-alternative-store <store_name> <store_location>, -uas <store_name> <store_location> - Update alternative commands store (JSON file).
  ```


  ```bash
  cmdcheatsheet -a <command> <command_description>
  ```
  for example:
  ```bash
  cmdcheatsheet -a "ls" "List directory content"
  ```


  Display all commands:
  ```bash
  cmdcheatsheet -c
  ```
  or:
  ```bash
  cmdcheatsheet
  ```
  Display commands along with ids:
  ```
  cmdcheatsheet -ci
  ```
  Display commands using table view:
  ```bash
  cmdcheatsheet -ct
  ```


  ```bash
  cmdcheatsheet -f <command>
  ```
  Search for a command and show it along with an id:
  ```bash
  cmdcheatsheet -fi <command>
  ```
  Search for a command and show it using the table view:
  ```bash
  cmdcheatsheet -ft <command>
  ```
  Global search includes search by command or description:
  ```bash
  cmdcheatsheet -gf <query>
  ```
  Global search and show it along with an id:
  ```bash
  cmdcheatsheet -gfi <query>
  ```


  ```bash
  cmdcheatsheet -u <command_id> <command> <command_description>
  ```


  ```bash
  cmdcheatsheet -d <command_id>
  ```


  ```bash
  cmdcheatsheet -acn
  ```


  cmdcheatsheet configuration folder is located at `~/.config/cmdcheatsheet`.\
  The config is called `config.json`


  * `currentStoreLocation` - Path to file in JSON format that consists of the command list.
  * `alternativeStores` - Path list to JSON files that might be used as an alternative commands store location.
  Every item in the list has a `storeName` property, which is just a store name and the second property is `storeLocation`, responsible for the path to the commands store (JSON file location).

  Here is a `config.json` example:
  ```json
  {
      "currentStoreLocation": "/Users/myusername/.config/cmdcheatsheet/commands.json",
      "alternativeStores": [
          {
              "storeName": "unix",
              "storeLocation": "/Users/myusername/my-configs/cmdcheatsheet/unix_commands.json"
          },
          {
              "storeName": "windows",
              "storeLocation": "/Users/myusername/my-configs/cmdcheatsheet/windows_commands.json"
          }
      ]
  }
  ```


  ```bash
  cmdcheatsheet -dc
  ```
  or display configuration by key:
  ```bash
  cmdcheatsheet -dc <config_key>
  ```


  This command displays all available configurations. Each command consists of a key and an explanation.
  ```bash
  cmdcheatsheet -dac
  ```


  ```bash
  cmdcheatsheet -sc <configuration_key> <configuration_value>
  ```


  ```bash
  cmdcheatsheet -rc <config_key>
  ```


  ```bash
  cmdcheatsheet -sctd
  ```


  ```bash
  cmdcheatsheet -ssctd <configuration_key>
  ```


  It's possible to have multiple command stores and switch between them.
  In this way, you'll be able to have separate configs for windows, Linux, and OSX, or in case you want to split the config in some other way.
  This feature is called alternative command stores.


  ```bash
  cmdcheatsheet -aas <store_name> <store_location>
  ```


  ```bash
  cmdcheatsheet -uas <store_name> <store_location>
  ```


  ```bash
  cmdcheatsheet -das <store_name>
  ```


  ```bash
  cmdcheatsheet -daas
  ```


  ```bash
  cmdcheatsheet -stas <store_name>
  ```


  ```bash
  cmdcheatsheet -daasn
  ```


  **Note:** that will include **[Rich](https://rich.readthedocs.io/)**.
  Rich is a library to display information on the terminal, it is required, and when installed, it's deeply integrated into **cmdcheatsheet** to display beautiful output.



  This project is licensed under the terms of the MIT license.


pkgId: 709d5eb8873cb102cb0921f2da4d4452ff4ed917d89479dcc3b524b974189eae
name: python-cmdcomp
arch: src
version: 2.6.0
epoch: 0
release: 1
summary: command shell completion file generator.
url: https://yassun7010.github.io/cmdcomp/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmdcomp-2.6.0-1.src.rpm
checksum_type: sha256
description:
  <!-- --8<-- [start:badges] -->

  [![docs](https://github.com/yassun7010/cmdcomp/actions/workflows/publish-mkdocs.yml/badge.svg)](https://yassun7010.github.io/cmdcomp/)
  [![test](https://github.com/yassun7010/cmdcomp/actions/workflows/test-suite.yml/badge.svg)](https://github.com/yassun7010/cmdcomp/actions)
  [![pypi package](https://badge.fury.io/py/cmdcomp.svg)](https://pypi.org/project/cmdcomp)
  [![docker version](https://img.shields.io/docker/v/yassun7010/cmdcomp/latest?label=docker%20version)](https://hub.docker.com/r/yassun7010/cmdcomp)

  <!-- --8<-- [end:badges] -->

  `cmdcomp` generate command shell completion file (`bash` or `zsh`) from config
  `JSON`/`YAML`/`TOML` file.

  ![image](./docs/images/image.png)



  The completion files for many cli tools (`aws`, `gcloud`, etc.) are provided by the tools themselves.
  If you want to use these cli tools in multiple products or multiple environments (prd, dev, etc.),
  it is useful to be able to switch contexts easily (e.g. `mycli prd aws s3 ...`).
  `cmdcomp` provides a completion file for such a simple shell script wrapper.
  You can easily switch between settings for each environment.

  This tool can generate shell script completion files with config described in `YAML`, `TOML` or `JSON`.

  Today, more and more cli tools are being used in development,
  and if you want to generate a completion file for a simple wrapper script,
  `cmdcomp` will be of great help.




  ```shell
  pip install cmdcomp
  ```



  ```shell
  cmdcomp --config $YOUR_CONFIG_FILE --shell-type bash
  ```



  See [documentation](https://yassun7010.github.io/cmdcomp/) for more details.



  See [examples](https://github.com/yassun7010/cmdcomp/tree/main/examples/v2).


pkgId: dd062c30e32f2112633c973c443fc95aa21146ac6a9ec3bcd2c4902b766d395b
name: python-cmdcraft
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/weinsen/cmdcraft
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmdcraft-0.0.4-1.src.rpm
checksum_type: sha256
description:
  ``cmdcraft`` is a library that aims to build fast and stable
  interative devtools. It that native Python metadata from objects to build prompt
  commands, so you don't have to manually configure input options.


pkgId: 9303c21c2e9d3379e3b9a867e8d9931f0650b00d2a8c92b8904e0c18717d6dc8
name: python-cmdi
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: A command interface
url: https://github.com/feluxe/cmdi
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmdi-2.0.0-1.src.rpm
checksum_type: sha256
description:
  10
  foo_cmd: Ok
  ```
  and return a `CmdResult` object:
  ```python
  CmdResult(
      val=20,
      code=0,
      name='foo_cmd',
      status=Status.ok,
      color=StatusColor.green,
      stdout=None,
      stderr=None
  )
  ```

  You can define the behavior of a command function using a set of special keyword arguments that are applied to the decorated function.
  In this example we redirect the output of `foo_cmd` to an in-memory file writer and catch exceptions. The output and information of the exception are then returned with the `CmdResult()` object:
  ```python
  from cmdi import CmdResult, Pipe
  result = foo_cmd(10, _stdout=Pipe(), _catch_err=True)
  isinstance(result, CmdResult) # True
  print(result.stdout) # prints caught output.
  ```
  More about special keyword arguments can be found in the API documentation below.

  A command always returns a `CmdResult` object, for which the `@command` wrapper function automatically sets the values for the fields (`code`, `status`, `color`, ...), which is good enough in many situations. But sometimes you need fine grained control over the return values, e.g. to create function specific return codes. In these situations you can explicitly return a `CmdResult` object with some or all of the fields set by yourself:
  ```python
  @command
  def foo_cmd(x: str, **cmdargs) -> CmdResult:
      print(x)
      somestr = "foo" + x
      if x == "bar":
          code = 0
      else:
          code = 42
      
      return CmdResult(
          val=somestr,
          code=code,
      )
  ```
  **Note:** In the example above, we return a customized `CmdResult` for which we only customize the fields `val` and `code`. You can customize every field of the `CmdResult` object (optionally). The fields you leave out are set automatically.

  Sometimes you want to use the _Command Interface_ for an existing function, without touching the function definition. You can do so by creating a _Command Interface Function Wrapper_:
  ```python
  from cmdi import command, strip_cmdargs, CmdResult

  @command
  def foo_cmd(x, **cmdargs) -> CmdResult:
      return foo(**strip_cmdargs(loclas()))

  def foo(x) -> int:
      print(x)
      return x * 2
  ```

  If you need to create a _Command Interface Function Wrapper_ for an existing function that runs a `subprocess` and your command depends on the `returncode` of that, you can use the `subprocess.CalledProcessError` exception to compose something. E.g.:
  ```python
  import subprocess as sp
  from cmdi import command, CmdResult, Status
  @command
  def foo_cmd(x, **cmdargs) -> CmdResult:
      try:
          return foo(**strip_cmdargs(locals()))
      except sp.CalledProcessError as e:
          if e.returncode == 13:
              return CmdResult(
                  code=e.returncode,
                  status=Status.ok,
              )
          elif e.returncode == 42:
              return CmdResult(
                  code=e.returncode,
                  status=Status.skip,
              )
          else:
              raise sp.CalledProcessError(e.returncode, e.args)
  def foo(x) -> int:
      return sp.run(["my_arg"], check=True, ...)
  ```


  This decorator allows you to apply the _command interface_ to a function.
  A function decorated with `@command` can take the following keyword arguments:

  Enable/Disable printing of command header and status information during runtime.
  **Example:**
  ```python
  result = my_command_func("some_arg", _verbose=False)
  ```

  Enable/Disable color for command header and status information.
  **Example:**
  ```python
  result = my_command_func("some_arg", _color=False)
  ```

  Redirect stdout of the child function. More on `Pipe()` below.
  **Example:**
  ```python
  from cmdi import Pipe
  pipe = Pipe(text=False, tty=True, ...) # See Pipe doc for arguments...
  result = my_command_func('foo', _stdout=pipe)
  print(result.stdout) # Prints the caught ouput.
  ```

  Redirect stderr of the child function. More on `Pipe()` below.
  **Example:**
  ```python
  from cmdi import Pipe
  pipe = Pipe(text=False, tty=True, ...) # See Pipe doc for arguments...
  result = my_command_func('foo', _stderr=pipe))
  print(result.stderr) # Prints the caught ouput.
  ```
  If you want to redirect `stderr` to `stdout`, you can use this:
  ```python
  from cmdi import STDOUT
  result = my_command_func('foo', _stderr=STDOUT))
  ```

  Catch errors from child function.
  This will let the runtime continue, even if a child function throws an exception. If an exception occurs the `CmdResult` object will provide information about the error at `result.stderr`, `result.code` and `result.status`. The status message will appear in red.
  **Example:**
  ```python
  from cmdi import Pipe
  r = my_command_func("some_arg", _catch_err=True, _stderr=Pipe())
  r.status # Error
  r.code # 1
  r.stdout # The stderr output from the function call.
  ```

  The command result object.
  A function decorated with `@command` returns a `CmdResult` object:
  ```python
  class CmdResult:
      val: T, # The return value of the wrapped function.
      code: int, # Return code
      name: str, # Command name. By default the name of the wrapped function.
      status: Optional[Status],
      color: Optional[StatusColor],
      stdout: Optional[Union[str, bytes]] = None,
      stderr: Optional[Union[str, bytes]] = None,
  ```

  Use this type to configure `stdout`/`stderr` for a command call.
  **Parameters**
  - `save: bool = True` - Save the function output if `True`.
  - `text: bool = True` - Save function output as text if `True` else save as bytes.
  - `dup: bool = False` - Redirect output at file descriptor level if `True`. This allows you to redirect output of subprocesses and C code. It's *dup* because we're duping file descriptors.
  - `tty: bool = False` - Keep ANSI sequences for saved output if `True`, else strip ANSI sequences.
  - `mute: bool = False` - Mute output of function call in terminal if `True`. NOTE: You can still save and return the output if this is enabled.
  **Example:**
  ```python
  from cmdi import CmdResult, Pipe
  out_pipe = Pipe(text=False, dup=True, mute=True)
  err_pipe = Pipe(text=False, dup=True, mute=False)
  result = foo_cmd(10, _stdout=out_pipe, _stderr=err_pipe, _catch_err=True)
  print(result.stdout) # prints caught output.
  print(result.stderr) # prints caught output.
  ```

  If you want to redirect the output of a function that runs a subprocess or calls foreign code, you have to use a `Pipe` with the argument `dup=True`. This will catch the output of stdout/stderr at a lower level (by duping file descriptors):
  ```python
  import subprocess
  from cmdi import command, Pipe
  @command
  def foo(x, **cmdargs) -> CmdResult:
      subprocess.run("my_script")

  foo(_stdout=Pipe(dup=True))
  ```

  **Parameters**
  - `locals_: Dict[str, Any]`
  **Returns**
  - `Dict[str, Any]`
  Remove cmdargs from dictionary.
  This function helps us to easily create _Command Interface Function Wrappers_.
  Example usage:
  ```python
  def foo(x):
      
      return x * 2
  @command
  def foo_cmd(x, **cmdargs):
      return foo(strip_cmdargs(locals()))
  ```

  **Parameter**
  -   `result: CmdResult`
  -   `color: bool = True`
  -   `file: Optional[IO[str]] = None`
  **Returns**
  -   `None`
  Print the title for a command result.
  **Example usage:**
  ```python
  result = my_cmd('foo')
  print_title(result)
  ```
  Output:
  ```


pkgId: e4bd73001c9652bfc4915f0c34c06c9703557f4c12c0f453013a368d175df926
name: python-cmdint
arch: src
version: 3.0.6
epoch: 0
release: 1
summary: Enables detailed logging of command line calls in a very lightweight manner.
url: https://github.com/MIC-DKFZ/cmdint/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmdint-3.0.6-1.src.rpm
checksum_type: sha256
description:
  CmdInterface enables detailed logging of command line and python experiments in a very lightweight manner (coding wise). It wraps your command line or python function calls in a few lines of code and logs everything you might need to reproduce the experiment later on or to simply check what you did a couple of years ago.


pkgId: 6991ee5150c2c194cea5dceaba4921af11c8ca85128f95cca312757c0b248118
name: python-cmdix
arch: src
version: 3.1.3
epoch: 0
release: 1
summary: Unix commands in Pure Python
url: https://pypi.org/project/cmdix/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmdix-3.1.3-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://img.shields.io/pypi/v/cmdix.svg
     :target: https://pypi.org/project/cmdix

  .. image:: https://img.shields.io/pypi/pyversions/cmdix.svg

  .. image:: https://github.com/jaraco/cmdix/actions/workflows/main.yml/badge.svg
     :target: https://github.com/jaraco/cmdix/actions?query=workflow%3A%22tests%22
     :alt: tests

  .. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json
      :target: https://github.com/astral-sh/ruff
      :alt: Ruff

  .. image:: https://readthedocs.org/projects/cmdix/badge/?version=latest
     :target: https://cmdix.readthedocs.io/en/latest/?badge=latest

  .. image:: https://img.shields.io/badge/skeleton-2024-informational
     :target: https://blog.jaraco.com/skeleton

  cmdix is a pure Python implementation of various standard UNIX commands,
  like 'ls', 'cp' and 'sleep'. It also contains a shell-like environment which
  will make Unix-users feel right at home on the Windows command-prompt.

  Forked from the abandoned `pycoreutils project
  <https://pypi.org/project/pycoreutils>`_ by Hans van Leeuwen.


pkgId: 40f91f75fdcccc8f04adfa817a1ebb076a98b18f8e8c1437bd73c699ef22866c
name: python-cmdkit
arch: src
version: 2.7.5
epoch: 0
release: 1
summary: A command-line utility toolkit for Python.
url: https://cmdkit.readthedocs.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmdkit-2.7.5-1.src.rpm
checksum_type: sha256
description:
  A library for developing command-line applications in Python.
  |
  The *cmdkit* library implements a few common patterns needed by well-formed command-line
  applications in Python. It only touches a few concepts but it implements them well.
  The idea is to reduce the boilerplate needed to get a full featured CLI off the ground.
  Applications developed using *cmdkit* are easy to implement, easy to maintain, and easy to
  understand.
  |


pkgId: 7f0a8d8c59f37cf3843296202f0e3774771acc5d0d6304e5c53972e412cb5efb
name: python-cmdline
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Utilities for consistent command line tools
url: http://github.com/rca/cmdline
rpm_license: LICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmdline-0.2.0-1.src.rpm
checksum_type: sha256
description:
  The cmdline package provides a standard way to specify and override command settings and logging configuration.  Using cmdline setttings is as simple as creating a `settings.yml`:
  ```
  REMOTE_ADDR:
    default: 'https://example.com/'
    help: the remote address
  ```
  and compiling the settings in your main program:
  ```
  from cmdline import SettingsParser, settings


  def main():
      SettingsParser.compile_settings()

      remote = settings.REMOTE_ADDR

      print('remote addr:', remote)


  if __name__ == '__main__':
      sys.exit(main())
  ```
  Your program can then be called in any of the following ways:
  ```
  $ remote
  remote addr: https://example.com/
  $ export REMOTE_ADDR=https://env.example.com/
  $ remote
  remote addr: https://env.example.com/
  $ remote --remote-addr=https://arg-takes-precedence.example.com/
  remote addr: https://arg-takes-precedence.example.com/
  ```


  ```
  pip install cmdline
  ```


  Settings are configured in an overlaid fashion starting with a root configuration packaged with the application.  Standard [argparse](https://docs.python.org/3/library/argparse.html) options are used to configure settings.


  The packaged settings can be overridden by additional settings files on the filesystem, environment variables, and finally command line arguments.  For a command named `remote` order in which they are applied are:

  - packaged settings
  - <sys.prefix>/etc/remote/settings.yml
  - ~/.remote/settings.yml
  - environment variables
  - command line arguments

  Environment variables map exactly to the name of the setting, i.e. the environment variable `REMOTE_ADDR` configures the `REMOTE_ADDR` setting.

  Command line arguments are lowercase-dashed versions of the setting, for instance, the command line argument `--remote-addr` configures the `REMOTE_ADDR` setting.


  The settings parser supports [argparse subcommands](https://docs.python.org/3/library/argparse.html#sub-commands).  A setting can be configured to be for a subcommand by adding a `_subcommand` key to the setting's options.  For example:
  ```
  COPY_FORCE
    default: no
    _subcommand: copy
  ```
  The `_SUBCOMMAND` setting contains the name of the subcommand the command was run with.


  Command descriptions and help text can be added in a `_COMMANDS` section.  The `_main` will set the description for the main program.  Any other keys will correspond to a subcommand by the same name.  For example, below sets the description for the main program and the description and help text for the `copy` subcommand:
  ```
  _COMMANDS:
    _main:
      description: >
        this is main description and can be a very long string
        that covers multiple lines
    copy:
      description: >
        this is copy subcommand description and can be a very long string
        that covers multiple lines
      help: copy files
  ```

  Settings can be converted to a particular type using argparse's `type` setting.  For example setting `type: int` will convert the setting into an integer.  This is done by using Python's built-in `int()` function.

  When `type` is a dotted string, the given function will be imported and used.  For example, setting `type: convesion.convert_bool` will call the `convert_bool()` function in the [conversion](https://pypi.python.org/pypi/conversion) package.


  Similarly, logging is configured through Python's `logging.config.dictConfig()` function.  More info on dictconfig is at [docs.python.org](https://docs.python.org/3/library/logging.config.html#logging.config.dictConfig); an example is below.  This configuration sets a `console` handler that sends logs to stdout and a `null` handler that throws away logs.  The default logging configuration is to log WARN level and higher messages to the console, which is setup by the `root` logger, and two additional loggers are configured for the `mypkg.foo` and `mypkg.bar` loggers, where the loglevel for `mypkg.foo` is set to DEBUG and `mypkg.bar` is thrown out altogether.

  ```
  version: 1
  disable_existing_loggers: False

  formatters:
    simple:
      format: "s s:d s s"


  handlers:
    console:
      class: logging.StreamHandler
      level: WARN
      formatter: simple
      stream: ext://sys.stdout

    "null":
      class: logging.NullHandler


  loggers:
    mypkg.foo:
      level: DEBUG
      handlers: [console]
      propagate: no

    mypkg.bar:
      handlers: ["null"]
      propagate: no


  root:
    level: WARN
    handlers: [console]
  ```
  Once the configuration is written, logging is configured by calling the `setup_logging()` function:
  ```
  import logging
  from cmdline import setup_logging


  def main():
      setup_logging()

      logging.getLogger(__name__).warning('ello')


  if __name__ == '__main__':
      sys.exit(main())
  ```

  The only logging configuration that can be updated outside the configuration file is the default log level, which can be changed with the environment variable `LOG_LEVEL`; for example, `LOG_LEVEL=debug remote`.


  Create a directory named `config`.  In that directory, create the files `logconfig.yml` and `settings.yml`.  A bare-bones `setup.py` that installs these files correctly is below:
  ```

  import os

  from setuptools import setup


  def get_data_files(base):
      for dirpath, dirnames, filenames in os.walk(base):
          for filename in filenames:
              yield os.path.join(dirpath, filename)


  data_files = [
      ('config', list(get_data_files('config'))),
  ]

  setup(name='remote',
        version='0.0.1',
        packages=['remote'],
        data_files=data_files,
        entry_points = {
            'console_scripts': [
                'remote = remote.command:main',
            ],
        },
  )
  ```
  The file structure for the `setup.py` above looks like:
  ```
  root_dir/
  +- remote/
  |  +- __init__.py
  |  +- command.py
  +- config/
  |  +- logconfig.yml
  |  +- settings.yml
  +- setup.py
  ```

  Setting the environment variable `CMDLINE_CONFIG_ROOT` will make the given path the primary config location for settings and logging.


pkgId: 306f9dbe1ad7aaacfe7c280b591ef71f63e65253cb9987a0311a39a37d235d4c
name: python-cmdln
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: An improved cmd.py for writing multi-command scripts and shells.
url: http://github.com/trentm/cmdln
rpm_license: http://www.opensource.org/licenses/mit-license.php
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmdln-2.0.0-1.src.rpm
checksum_type: sha256
description:
  `cmdln.py` is an extension of Python's default `cmd.py` module that
  provides "a simple framework for writing line-oriented command
  interpreters".  The idea (with both cmd.py and cmdln.py) is to be able
  to quickly build multi-sub-command tools (think cvs or svn) and/or
  simple interactive shells (think gdb or pdb).  Cmdln's extensions make
  it more natural to write sub-commands, integrate optparse for simple
  option processing, and make having good command documentation easier.


pkgId: d9a757bc06f88e8af310c21b61760dbe4c42255cc7f9403fcc7051cb31b66d4c
name: python-cmdstanpy
arch: src
version: 1.2.4
epoch: 0
release: 1
summary: Python interface to CmdStan
url: https://github.com/stan-dev/cmdstanpy
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmdstanpy-1.2.4-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/stan-dev/cmdstanpy/branch/master/graph/badge.svg)](https://codecov.io/gh/stan-dev/cmdstanpy)


  CmdStanPy is a lightweight pure-Python interface to CmdStan which provides access to the Stan compiler and all inference algorithms.  It supports both development and production workflows. Because model development and testing may require many iterations, the defaults favor development mode and therefore output files are stored on a temporary filesystem. Non-default options allow all aspects of a run to be specified so that scripts can be used to distributed analysis jobs across nodes and machines.

  CmdStanPy is distributed via PyPi: https://pypi.org/project/cmdstanpy/

  or Conda Forge: https://anaconda.org/conda-forge/cmdstanpy



  - Clean interface to Stan services so that CmdStanPy can keep up with Stan releases.

  - Provide access to all CmdStan inference methods.

  - Easy to install,
    + minimal Python library dependencies: numpy, pandas
    + Python code doesn't interface directly with c++, only calls compiled executables

  - Modular - CmdStanPy produces a MCMC sample (or point estimate) from the posterior; other packages do analysis and visualization.

  - Low memory overhead - by default, minimal memory used above that required by CmdStanPy; objects run CmdStan programs and track CmdStan input and output files.




  CmdStanPy and CmdStan are available from GitHub: https://github.com/stan-dev/cmdstanpy and https://github.com/stan-dev/cmdstan




  The latest release documentation is hosted on  https://mc-stan.org/cmdstanpy, older release versions are available from readthedocs:  https://cmdstanpy.readthedocs.io



  The CmdStanPy, CmdStan, and the core Stan C++ code are licensed under new BSD.



  ```python
  import os
  from cmdstanpy import cmdstan_path, CmdStanModel


  stan_file = os.path.join(cmdstan_path(), 'examples', 'bernoulli', 'bernoulli.stan')
  data_file = os.path.join(cmdstan_path(), 'examples', 'bernoulli', 'bernoulli.data.json')


  model = CmdStanModel(stan_file=stan_file)


  fit = model.sample(chains=4, data=data_file)


  fit.summary()
  ```


pkgId: f3b280c854eea9ac191807ac1d71f37eac3b2cfbe0535fa83b0a138f483cc32f
name: python-cmdtools
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: A collection of tools relating to transfer operators
url: https://github.com/zib-cmd/cmdtools
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmdtools-1.0.2-1.src.rpm
checksum_type: sha256
description:
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/zib-cmd/cmdtools/HEAD?filepath=examples)
  [![Documentation](https://readthedocs.org/projects/cmdtools/badge/?version=latest)](https://cmdtools.readthedocs.io/en/latest/?badge=latest)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.4749330.svg)](https://doi.org/10.5281/zenodo.4749330)



  This Python library implements a suite of tools used and/or developed in the [Computational Molecular Design](https://www.zib.de/numeric/cmd) group of the Zuse Institute Berlin.




  Install with `pip install cmdtools`
      (If you want to use the SLEPc library for sparse Schur decompositions install cmdtools with the extra slepc, i.e. `pip install "cmdtools[slepc]"`)

  Note: It seems that `pip` has problems installing SLEPc. However, using conda you can install it with `conda install -c conda-forge petsc slepc petsc4py slepc4py`.


  *  `pcca`: An implementation of (generalized) PCCA⁺ using the Schur decomposition
  *  `ajc`: A sparse implementation of the augmented jump chain
  *  `diffusionmaps`: Diffusionmaps with sparse support and out of sample extensions
  *  `galerkin`: Trajectory based estimation of the transfer operator using a Galerkin projection onto Gaussian RBFs
  *  `gillespie`: Trajectory simulation from a generator
  *  `newton_generator`: Multi-step estimation of the generator via the Newton polynomial
  *  `picking_algorithm`: Given a set of datapoints, pick n points such that they are distributed as evenly / equidistant as possible
  *  `sqra`: The Square Root approximation, estimating the generator for the diffusion in a given potential
  *  `voronoi`: Voronoi clustering of trajectories and estimation of the transfer operator with different metrics and center strategies.
  *  `diffusion`: A collection of dynamical systems (So far the double- and triple-well)


  If you use cmdtools in your research, please [cite](CITATION.bib) our work.


pkgId: b32f5f8e3b820a254e06e43ccf4bcf9d3c8c7a1e8e87a3d2a8c2651e85e14aab
name: python-cmeel
arch: src
version: 0.53.3
epoch: 0
release: 1
summary: Create Wheel from CMake projects
url: https://github.com/cmake-wheel/cmeel
rpm_license: BSD-2-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmeel-0.53.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/cmeel.svg)](https://pypi.org/project/cmeel)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/cmake-wheel/cmeel/main.svg)](https://results.pre-commit.ci/latest/github/cmake-wheel/cmeel/main)
  [![Documentation Status](https://readthedocs.org/projects/cmeel/badge/?version=latest)](https://cmeel.readthedocs.io/en/latest/?badge=latest)

  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://python-poetry.org/)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v1.json)](https://github.com/charliermarsh/ruff)

  Wheel build backend using CMake, to package anything with pip and distribute on PyPI.

  Following those relevant PEPs:
  - [PEP 427](https://peps.python.org/pep-0427/), The Wheel Binary Package Format 1.0
  - [PEP 517](https://peps.python.org/pep-0517/), A build-system independent format for source trees
  - [PEP 518](https://peps.python.org/pep-0518/), Specifying Minimum Build System Requirements for Python Projects
  - [PEP 600](https://peps.python.org/pep-0600/), Future ‘manylinux’ Platform Tags for Portable Linux Built Distributions
  - [PEP 621](https://peps.python.org/pep-0621/), Storing project metadata in pyproject.toml
  - [PEP 639](https://peps.python.org/pep-0639/), Improving License Clarity with Better Package Metadata, **DRAFT**
  - [PEP 660](https://peps.python.org/pep-0660/), Editable installs for pyproject.toml based builds (wheel based)



  https://matrix.to/#/#cmake-wheel:matrix.org



  Glue between PEP 517 & 660 entry points and modern CMake standard project configuration / build / test / install

  This Install in `${PYTHON_SITELIB}/cmeel.prefix/`:
  - As there is a dot, it is not a valid python module name, so no risk of importing anything there by mistake
  - Play well with others, as everything is confined to `${PYTHON_SITELIB}/cmeel.prefix`
  - `${PYTHON_SITELIB}/cmeel.pth` automatically load `${PYTHON_SITELIB}/cmeel.prefix/${PYTHON_SITELIB}`, so python
    packages work out of the box
  - Existing `${PYTHON_SITELIB}/cmeel.prefix` are automatically added to `$CMAKE_PREFIX_PATH`, so we can build CMake
    packages whose dependencies are provided by other packages installed with cmeel
  - Stuff in `${PYTHON_SITELIB}/cmeel.prefix/bin` is exposed via `cmeel.run:cmeel_run`, or copied if start with a shebang



  extract from  https://github.com/cmake-wheel/cmeel-example/blob/main/pyproject.toml:

  ```toml
  [project]
  name = "cmeel-example"
  version = "0.4.12"
  description = "This is an example project, to show how to use cmeel"
  requires-python = ">= 3.7"
  license = "BSD-2-Clause"
  authors = [{name = "Guilhem Saurel", email = "guilhem.saurel@laas.fr"}]

  [project.urls]
  homepage = "https://github.com/cmake-wheel/cmeel-example"
  repository = "https://github.com/cmake-wheel/cmeel-example.git"
  changelog = "https://github.com/cmake-wheel/cmeel-example/blob/main/CHANGELOG.md"

  [build-system]
  requires = ["cmeel[build]"]
  build-backend = "cmeel"
  ```

  Complete specification is available at:
  https://packaging.python.org/en/latest/specifications/declaring-project-metadata



  If you want to use the helpers provided by cmeel, to *eg*. test building a project in a manylinux container with
  `cmeel docker`, the best way to install cmeel is to use pipx: `pipx install cmeel`

  Otherwise, if you just want to use the build backend, there is no need to install anything: your frontent (*eg.* `pip`)
  should do this for you


pkgId: 72ef17f18c93d2dbb804d04182badf58af576f82e23bcb52c468a973324d19d9
name: python-cmem-cmemc
arch: src
version: 24.2.0
epoch: 0
release: 1
summary: Command line client for eccenca Corporate Memory
url: https://eccenca.com/go/cmemc
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmem-cmemc-24.2.0-1.src.rpm
checksum_type: sha256
description:
  cmemc is the official command line client for [eccenca Corporate Memory](https://documentation.eccenca.com/).

  [![version][version-shield]][changelog] [![Python Versions][python-shield]][pypi] [![eccenca Corporate Memory][cmem-shield]][cmem]

  [![teaser][teaser-image]][cmemc-docu]



  In order to install the cmemc, run:

      pipx install cmem-cmemc

  Of course you can install cmemc also with pip, but we recommend [pipx](https://pypa.github.io/pipx/) for normal desktop usage.



  cmemc is intended for System Administrators and Linked Data Expert, who wants to automate and remote control activities on eccenca Corporate Memory.

  The cmemc manual including basic usage pattern, configuration as well as a command reference is available at:

  [https://eccenca.com/go/cmemc](https://eccenca.com/go/cmemc)

  cmemc only works with Python 3 and refuses to work with Python 2.x.
  In addition to that, cmemc will warn you in case an untested Python environment is used.


  [version-shield]: https://badge.fury.io/py/cmem-cmemc.svg
  [changelog]: https://pypi.org/project/cmem-cmemc/#history
  [python-shield]: https://img.shields.io/pypi/pyversions/cmem-cmemc.svg
  [pypi]: https://pypi.org/project/cmem-cmemc/
  [cmem]: https://documentation.eccenca.com
  [cmem-shield]: https://img.shields.io/badge/made%20for-eccenca%20Corporate%20Memory-blue?logo=data:image/svg%2bxml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiIHN0YW5kYWxvbmU9Im5vIj8+CjxzdmcKICAgaWQ9IkxheWVyXzEiCiAgIGRhdGEtbmFtZT0iTGF5ZXIgMSIKICAgdmlld0JveD0iMCAwIDgxLjI5MDAwMSA4Mi4yODk4NiIKICAgdmVyc2lvbj0iMS4xIgogICB3aWR0aD0iODEuMjkwMDAxIgogICBoZWlnaHQ9IjgyLjI4OTg2NCIKICAgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIgogICB4bWxuczpzdmc9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZGVmcwogICAgIGlkPSJkZWZzODI2Ij4KICAgIDxzdHlsZQogICAgICAgaWQ9InN0eWxlODI0Ij4KICAgICAgLmNscy0xIHsKICAgICAgICBmaWxsOiAjZjM5MjAwOwogICAgICB9CgogICAgICAuY2xzLTIgewogICAgICAgIGZpbGw6IG5vbmU7CiAgICAgICAgc3Ryb2tlOiAjZjM5MjAwOwogICAgICAgIHN0cm9rZS13aWR0aDogMS41cHg7CiAgICAgIH0KICAgIDwvc3R5bGU+CiAgPC9kZWZzPgogIDxnCiAgICAgaWQ9Imc4NDAiCiAgICAgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoLTMwLjc2LC0zMS4xNDAxMzkpIj4KICAgIDxwYXRoCiAgICAgICBjbGFzcz0iY2xzLTEiCiAgICAgICBkPSJNIDU1LjksODUuMTkgQSAyMC4xNCwyMC4xNCAwIDEgMCAzNS43Niw2NS4wNSAyMC4xNCwyMC4xNCAwIDAgMCA1NS45LDg1LjE5IFoiCiAgICAgICBpZD0icGF0aDgyOCIgLz4KICAgIDxwYXRoCiAgICAgICBjbGFzcz0iY2xzLTEiCiAgICAgICBkPSJtIDk4LDU0LjE0IGEgOSw5IDAgMSAwIC04Ljk1LC05IDguOTUsOC45NSAwIDAgMCA4Ljk1LDkgeiIKICAgICAgIGlkPSJwYXRoODMwIiAvPgogICAgPHBhdGgKICAgICAgIGNsYXNzPSJjbHMtMSIKICAgICAgIGQ9Ik0gODguMzUsMTA4LjQzIEEgMTIuMzEsMTIuMzEgMCAxIDAgNzYsOTYuMTIgMTIuMzEsMTIuMzEgMCAwIDAgODguMzEsMTA4LjQzIFoiCiAgICAgICBpZD0icGF0aDgzMiIgLz4KICAgIDxsaW5lCiAgICAgICBjbGFzcz0iY2xzLTIiCiAgICAgICB4MT0iODYuOTcwMDAxIgogICAgICAgeTE9IjkyLjA1OTk5OCIKICAgICAgIHgyPSI1OC43Nzk5OTkiCiAgICAgICB5Mj0iNjcuMzYwMDAxIgogICAgICAgaWQ9ImxpbmU4MzQiIC8+CiAgICA8bGluZQogICAgICAgY2xhc3M9ImNscy0yIgogICAgICAgeDE9Ijk5LjE4IgogICAgICAgeTE9IjQ1Ljg0IgogICAgICAgeDI9IjU1LjQ4IgogICAgICAgeTI9IjY2LjEyMDAwMyIKICAgICAgIGlkPSJsaW5lODM2IiAvPgogICAgPGxpbmUKICAgICAgIGNsYXNzPSJjbHMtMiIKICAgICAgIHgxPSI5Ny45ODk5OTgiCiAgICAgICB5MT0iNDQuNjUwMDAyIgogICAgICAgeDI9Ijg4LjM0OTk5OCIKICAgICAgIHkyPSI5Mi44Mzk5OTYiCiAgICAgICBpZD0ibGluZTgzOCIgLz4KICA8L2c+Cjwvc3ZnPgo=
  [teaser-image]: https://documentation.eccenca.com/24.1/automate/cmemc-command-line-interface/configuration/completion-setup/22.1-cmemc-create-dataset.gif
  [cmemc-docu]: https://eccenca.com/go/cmemc


pkgId: 3088577cfff8b2dd05280861561409db91d9f126627ba2a8d0b4b1493b4e1f97
name: python-cmem-cmempy
arch: src
version: 24.2.0
epoch: 0
release: 1
summary: API for eccenca Corporate Memory
url: https://eccenca.com/go/cmempy
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmem-cmempy-24.2.0-1.src.rpm
checksum_type: sha256
description:
  cmempy is a Python API wrapper for [eccenca Corporate Memory](https://documentation.eccenca.com/).



  To install the Python library run:

      pip install cmem-cmempy

  You may consider installing the package only for the current user:

      pip install cmem-cmempy --user



  cmempy is intended for Linked Data Experts to interface with the eccenca Corporate Memory backend components DataIntegration and DataPlatform.

  The cmempy manual including basic usage patterns and configuration is available at:

  [https://eccenca.com/go/cmempy](https://eccenca.com/go/cmempy)

  cmempy is tests with python 3.9 and 3.11.


pkgId: 9c1af68f99d917c0177a005482020eafad36b6fd689d017021fd29aac5bbcc56
name: python-cmem-plugin-base
arch: src
version: 4.8.0
epoch: 0
release: 1
summary: Base classes for developing eccenca Corporate Memory plugins.
url: https://pypi.org/project/cmem-plugin-base/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmem-plugin-base-4.8.0-1.src.rpm
checksum_type: sha256
description:
  Python base classes for developing eccenca Coporate Memory plugins.

  In order to kick-start developing eccenca Corporate Memory Plugins, please check out this project template: https://github.com/eccenca/cmem-plugin-template


pkgId: e17565e938990f127b3dd669d53ab7d588e8175c0ed2646f2ec4997d9b221181
name: python-cmem-plugin-kafka
arch: src
version: 3.2.0
epoch: 0
release: 1
summary: Send and receive messages from Apache Kafka.
url: https://github.com/eccenca/cmem-plugin-kafka
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmem-plugin-kafka-3.2.0-1.src.rpm
checksum_type: sha256
description:
  Send and receive messages from Apache Kafka.

  This is a plugin for [eccenca](https://eccenca.com) [Corporate Memory](https://documentation.eccenca.com).

  You can install it with the [cmemc](https://eccenca.com/go/cmemc) command line
  clients like this:

  ```
  cmemc admin workspace python install cmem-plugin-kafka
  ```





  An example XML document is shown below. This document will be sent as two messages
  to the configured topic. Each message is created as a proper XML document.

  ```xml
  <?xml version="1.0" encoding="utf-8"?>
  <KafkaMessages>
      <Message>
          <PurchaseOrder OrderDate="1996-04-06">
              <ShipTo country="string">
                  <name>string</name>
                  <street>string</street>
                  <city>string</city>
                  <state>string</state>
                  <zip>9200</zip>
              </ShipTo>
              <BillTo country="string">
                  <name>string</name>
                  <street>string</street>
                  <city>string</city>
                  <state>string</state>
                  <zip>2381</zip>
              </BillTo>
          </PurchaseOrder>
      </Message>
      <Message key="1234">
          <SingleTagHere>
              .
              .
              .
          </SingleTagHere>
      </Message>
  </KafkaMessages>
  ```
  Producer plugin generates 2 messages with below content
  ```xml
  <?xml version="1.0" encoding="utf-8"?>
  <PurchaseOrder OrderDate="1996-04-06">
      <ShipTo country="string">
          <name>string</name>
          <street>string</street>
          <city>string</city>
          <state>string</state>
          <zip>9200</zip>
      </ShipTo>
      <BillTo country="string">
          <name>string</name>
          <street>string</street>
          <city>string</city>
          <state>string</state>
          <zip>2381</zip>
      </BillTo>
  </PurchaseOrder>
  ```
  ```xml
  <?xml version="1.0" encoding="utf-8"?>
  <SingleTagHere>
              .
              .
              .
  </SingleTagHere>
  ```


  An example JSON document is shown below. This document will be sent as two messages
  to the configured topic. Each message is created as a proper JSON document.

  ```json
  [
    {
      "message": {
        "key": "818432-942813-832642-453478",
        "headers": {
          "type": "ADD"
        },
        "content": {
          "location": [
            "Leipzig"
          ],
          "obstacle": {
            "name": "Iron Bars",
            "order": "1"
          }
        }
      }
    },
    {
      "message": {
        "key": "887428-119918-570674-866526",
        "headers": {
          "type": "REMOVE"
        },
        "content": {
          "comments": "We can pass any json payload here."
        }
      }
    }
  ]
  ```
  Producer plugin generates 2 messages with below content
  ```json
  {
    "location": [
      "Leipzig"
    ],
    "obstacle": {
      "name": "Iron Bars",
      "order": "1"
    }
  }
  ```
  ```json
  {
    "comments": "We can pass any json payload here."
  }
  ```


  Random values plugin entities will generate below format JSON document.

  ```json
  {
    "schema": {
      "type_uri": "https://example.org/vocab/RandomValueRow"
    },
    "entity": {
      "uri": "urn:uuid:3c68d8e7-bf17-4045-a9eb-c9c9813f717f",
      "values": {
        "<https://example.org/vocab/RandomValuePath0>": [
          "a8o4Ocsb6RZClFRUZU3b2w"
        ],
        "<https://example.org/vocab/RandomValuePath1>": [
          "RTICRU7JcTUVn94decelPg"
        ],
        "<https://example.org/vocab/RandomValuePath2>": [
          "A9r-969NjAlX0DNWftxKoA"
        ],
        "<https://example.org/vocab/RandomValuePath3>": [
          "FygWRy1UJ4-IzIim1qukJA"
        ],
        "<https://example.org/vocab/RandomValuePath4>": [
          "AJcbn-LJEs-Dif96xu2eww"
        ]
      }
    }
  }
  ```


pkgId: 45137a9f94ca494958890e0313bb3bd00f1eb6d0f7da9e54ee59ce73b91b0463
name: python-cmem-plugin-kaggle
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Import dataset resources from Kaggle.
url: https://github.com/eccenca/cmem-plugin-kaggle
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmem-plugin-kaggle-2.0.1-1.src.rpm
checksum_type: sha256
description:
  Import dataset resources from [Kaggle](https://www.kaggle.com/).

  [![eccenca Corporate Memory][cmem-shield]][cmem-link]

  This is a plugin for [eccenca](https://eccenca.com) [Corporate Memory](https://documentation.eccenca.com). You can install it with the [cmemc](https://eccenca.com/go/cmemc) command line clients like this:

  ```
  cmemc admin workspace python install cmem-plugin-kaggle
  ```
  [![workflow](https://github.com/eccenca/cmem-plugin-kaggle//actions/workflows/check.yml/badge.svg)](https://github.com/eccenca/cmem-plugin-kaggle//actions) [![pypi version](https://img.shields.io/pypi/v/cmem-plugin-kaggle)](https://pypi.org/project/cmem-plugin-kaggle) [![license](https://img.shields.io/pypi/l/cmem-plugin-kaggle)](https://pypi.org/project/cmem-plugin-kaggle)
  [![poetry][poetry-shield]][poetry-link] [![ruff][ruff-shield]][ruff-link] [![mypy][mypy-shield]][mypy-link] [![copier][copier-shield]][copier]

  [cmem-link]: https://documentation.eccenca.com
  [cmem-shield]: https://img.shields.io/endpoint?url=https://dev.documentation.eccenca.com/badge.json
  [poetry-link]: https://python-poetry.org/
  [poetry-shield]: https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json
  [ruff-link]: https://docs.astral.sh/ruff/
  [ruff-shield]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&label=Code%20Style
  [mypy-link]: https://mypy-lang.org/
  [mypy-shield]: https://www.mypy-lang.org/static/mypy_badge.svg
  [copier]: https://copier.readthedocs.io/
  [copier-shield]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-inverted-border-purple.json


pkgId: bca888ca7d82862611b75389e829da5b23c574f064a192843bb2ecced559a8b0
name: python-cmem-plugin-pyshacl
arch: src
version: 5.0.2
epoch: 0
release: 1
summary: Validate your Knowledge Graphs based on tests generated from SHACL shapes.
url: https://github.com/eccenca/cmem-plugin-pyshacl
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmem-plugin-pyshacl-5.0.2-1.src.rpm
checksum_type: sha256
description:
  Validate your Knowledge Graphs based on tests generated from SHACL shapes.

  [![eccenca Corporate Memory][cmem-shield]][cmem-link]

  This is a plugin for [eccenca](https://eccenca.com) [Corporate Memory](https://documentation.eccenca.com). You can install it with the [cmemc](https://eccenca.com/go/cmemc) command line clients like this:

  ```
  cmemc admin workspace python install cmem-plugin-pyshacl
  ```






  The URI of the data graph to be validated. The graph URI is selected from a list of graphs of types:
  - `di:Dataset`
  - `dsm:ThesaurusProject`
  - `owl:Ontology`
  - `shui:ShapeCatalog`
  - `void:Dataset`



  The URI of the graph containing the SHACL shapes to be validated against. The graph URI is selected from a list of graphs of type `shui:ShapeCatalog`



  If enabled, the validation graph is posted to the CMEM instance with the graph URI specified with the *validation graph URI* option. Default value: *false*



  If the *generate validation graph* option is enabled the validation graph is posted to the CMEM instance with this graph URI



  If enabled, the plugin outputs the validation results and can be connected to, for instance, a CSV dataset to produce a results table. Default value: *false*



  If enabled, the validation graph is cleared before workflow execution. Default value: *true*.





  If enabled, the graph tree defined with `owl:imports` in the data graph is resolved. Default value: *true*



  If enabled, blank nodes in the validation graph are skolemized into URIs. Default value: *true*



  If enabled, `rdfs:label` triples are added to the validation graph for instances of `sh:ValidationReport` and `sh:ValidationResult`. Default value: *true*



  If enabled along with the *add labels* option, `rdfs:label` triples are added for the focus nodes, values and SHACL shapes in the validation graph. The labels are taken from the specified data and SHACL graphs. Default value: *false*



  If enabled, `shui:conforms false` triples are added to the focus nodes in the validation graph. Default value: *false*



  If enabled, the SHACL shapes graph is validated against the SHACL-SHACL shapes graph before validating the data graph. Default value: *false*



  The URI of a graph containing extra ontological information. RDFS and OWL definitions from this are used to inoculate the data graph. The graph URI is selected from a list of graphs of type `owl:Ontology`



  If enabled, OWL inferencing expansion of the data graph is performed before validation. Options are *RDFS*, *OWLRL*, *Both*, *None*. Default value: *None*



  Enable SHACL Advanced Features. Default value: *false*.



  The maximum number of SHACL shapes "deep" that the validator can go before reaching an "endpoint" constraint (1-999). Default value: 15




  In order to set options via the input the following parameter names can be used:

  | Option                                         | Name                   |
  |------------------------------------------------|------------------------|
  | Data graph URI                                 | data_graph_uri         |
  | SHACL graph URI                                | shacl_graph_uri        |
  | Generate validation graph                      | generate_graph         |
  | Validation graph URI                           | validation_graph_uri   |
  | Output entities                                | output_entities        |
  | Clear validation graph                         | clear_validation_graph |
  | Resolve owl:imports                            | owl_imports            |
  | Blank node skolemization                       | skolemize              |
  | Add labels                                     | add_labels             |
  | Add labels from data and SHACL graphs          | include_graphs_labels  |
  | Add shui:conforms flag to focus node resources | add_shui_conforms      |
  | Meta-SHACL                                     | meta_shacl             |
  | Ontology graph URI                             | ontology_graph_uri     |
  | Inference                                      | inference              |
  | Advanced                                       | advanced               |
  | Maximum evaluation depth                       | max_evaluation_depth   |



  [![workflow](https://github.com/eccenca/cmem-plugin-pyshacl/actions/workflows/check.yml/badge.svg)](https://github.com/eccenca/cmem-plugin-pyshacl/actions) [![pypi version](https://img.shields.io/pypi/v/cmem-plugin-pyshacl)](https://pypi.org/project/cmem-plugin-pyshacl) [![license](https://img.shields.io/pypi/l/cmem-plugin-pyshacl)](https://pypi.org/project/cmem-plugin-pyshacl)
  [![poetry][poetry-shield]][poetry-link] [![ruff][ruff-shield]][ruff-link] [![mypy][mypy-shield]][mypy-link] [![copier][copier-shield]][copier]

  [cmem-link]: https://documentation.eccenca.com
  [cmem-shield]: https://img.shields.io/endpoint?url=https://dev.documentation.eccenca.com/badge.json
  [poetry-link]: https://python-poetry.org/
  [poetry-shield]: https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json
  [ruff-link]: https://docs.astral.sh/ruff/
  [ruff-shield]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&label=Code%20Style
  [mypy-link]: https://mypy-lang.org/
  [mypy-shield]: https://www.mypy-lang.org/static/mypy_badge.svg
  [copier]: https://copier.readthedocs.io/
  [copier-shield]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-inverted-border-purple.json


pkgId: d2379f608dbf331f3dd17d3c0190a6dce43e3ca5d56bf1445a5c1993d69e2ab5
name: python-cmem-plugin-python
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Write ad-hoc transformations and workflow tasks with Python.
url: https://github.com/eccenca/cmem-plugin-python
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmem-plugin-python-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Write ad-hoc transformations and workflow tasks with Python.

  [![eccenca Corporate Memory][cmem-shield]][cmem-link]

  This is a plugin for [eccenca](https://eccenca.com) [Corporate Memory](https://documentation.eccenca.com). You can install it with the [cmemc](https://eccenca.com/go/cmemc) command line clients like this:

  ```
  cmemc admin workspace python install cmem-plugin-python
  ```
  [![workflow](https://github.com/eccenca/cmem-plugin-python/actions/workflows/check.yml/badge.svg)](https://github.com/eccenca/cmem-plugin-python/actions) [![pypi version](https://img.shields.io/pypi/v/cmem-plugin-python)](https://pypi.org/project/cmem-plugin-python) [![license](https://img.shields.io/pypi/l/cmem-plugin-python)](https://pypi.org/project/cmem-plugin-python)
  [![poetry][poetry-shield]][poetry-link] [![ruff][ruff-shield]][ruff-link] [![mypy][mypy-shield]][mypy-link] [![copier][copier-shield]][copier]

  [cmem-link]: https://documentation.eccenca.com
  [cmem-shield]: https://img.shields.io/endpoint?url=https://dev.documentation.eccenca.com/badge.json
  [poetry-link]: https://python-poetry.org/
  [poetry-shield]: https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json
  [ruff-link]: https://docs.astral.sh/ruff/
  [ruff-shield]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&label=Code%20Style
  [mypy-link]: https://mypy-lang.org/
  [mypy-shield]: https://www.mypy-lang.org/static/mypy_badge.svg
  [copier]: https://copier.readthedocs.io/
  [copier-shield]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-inverted-border-purple.json


pkgId: 90917039270287cb1801f260764348ac09e144ae85851c3e9a1022efc61585f1
name: python-cmem-plugin-reason
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Perform reasoning tasks and validate OWL consistency.
url: https://github.com/eccenca/cmem-plugin-reason
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmem-plugin-reason-2.0.0-1.src.rpm
checksum_type: sha256
description:
  Perform reasoning tasks and validate OWL consistency.


  [![eccenca Corporate Memory][cmem-shield]][cmem-link]


  This is a plugin for [eccenca](https://eccenca.com) [Corporate Memory](https://documentation.eccenca.com). You can install it with the [cmemc](https://eccenca.com/go/cmemc) command line clients like this:

  ```
  ➜ cmemc admin workspace python install cmem-plugin-reason
  ```
  [![workflow](https://github.com/eccenca/cmem-plugin-reason/actions/workflows/check.yml/badge.svg)](https://github.com/eccenca/cmem-plugin-reason/actions) [![pypi version](https://img.shields.io/pypi/v/cmem-plugin-reason)](https://pypi.org/project/cmem-plugin-reason) [![license](https://img.shields.io/pypi/l/cmem-plugin-reason)](https://pypi.org/project/cmem-plugin-reason)
  [![poetry][poetry-shield]][poetry-link] [![ruff][ruff-shield]][ruff-link] [![mypy][mypy-shield]][mypy-link] [![copier][copier-shield]][copier]

  [cmem-link]: https://documentation.eccenca.com
  [cmem-shield]: https://img.shields.io/endpoint?url=https://dev.documentation.eccenca.com/badge.json
  [poetry-link]: https://python-poetry.org/
  [poetry-shield]: https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json
  [ruff-link]: https://docs.astral.sh/ruff/
  [ruff-shield]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&label=Code%20Style
  [mypy-link]: https://mypy-lang.org/
  [mypy-shield]: https://www.mypy-lang.org/static/mypy_badge.svg
  [copier]: https://copier.readthedocs.io/
  [copier-shield]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-inverted-border-purple.json

  ROBOT is published under the [BSD 3-Clause "New" or "Revised" License](https://choosealicense.com/licenses/bsd-3-clause/).
  Copyright © 2015, the authors. All rights reserved.


pkgId: 217c8e1c3fad7bba044c737e0adb611950991a0ef21acc9d1ffd855d80676cf8
name: python-cmem-plugin-shapes
arch: src
version: 1.0.0b2
epoch: 0
release: 1
summary: Generate SHACL node and property shapes from a data graph
url: https://github.com/eccenca/cmem-plugin-shapes
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmem-plugin-shapes-1.0.0b2-1.src.rpm
checksum_type: sha256
description:
  Generate SHACL node and property shapes from a data graph.

  [![eccenca Corporate Memory][cmem-shield]][cmem-link]


  You can install it with the [cmemc](https://eccenca.com/go/cmemc) command line
  clients with:

  ```
  cmemc admin workspace python install cmem-plugin-shapes
  ```


  [![workflow](https://github.com/eccenca/cmem-plugin-shapes/actions/workflows/check.yml/badge.svg)](https://github.com/eccenca/cmem-plugin-shapes/actions) [![pypi version](https://img.shields.io/pypi/v/cmem-plugin-shapes)](https://pypi.org/project/cmem-plugin-shapes) [![license](https://img.shields.io/pypi/l/cmem-plugin-shapes)](https://pypi.org/project/cmem-plugin-shapes)

  [![poetry][poetry-shield]][poetry-link] [![ruff][ruff-shield]][ruff-link] [![mypy][mypy-shield]][mypy-link] [![copier][copier-shield]][copier]

  [cmem-link]: https://documentation.eccenca.com
  [cmem-shield]: https://img.shields.io/endpoint?url=https://dev.documentation.eccenca.com/badge.json
  [poetry-link]: https://python-poetry.org/
  [poetry-shield]: https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json
  [ruff-link]: https://docs.astral.sh/ruff/
  [ruff-shield]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&label=Code%20Style
  [mypy-link]: https://mypy-lang.org/
  [mypy-shield]: https://www.mypy-lang.org/static/mypy_badge.svg
  [copier]: https://copier.readthedocs.io/
  [copier-shield]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-inverted-border-purple.json


pkgId: f14f4e60157bfaa4544f22b0423b9cc4fcdb4df27952712eb2889046b6ff1cbd
name: python-cmem-plugin-sparql-anything
arch: src
version: 0.0.1rc7
epoch: 0
release: 1
summary: Query file to generate knowledge graph
url: https://github.com/eccenca/cmem-plugin-sparql-anything
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmem-plugin-sparql-anything-0.0.1rc7-1.src.rpm
checksum_type: sha256
description:
  Query file to generate knowledge graph



  This is a plugin for [eccenca](https://eccenca.com) [Corporate Memory](https://documentation.eccenca.com).

  You can install it with the [cmemc](https://eccenca.com/go/cmemc) command line
  clients like this:

  ```
  cmemc admin workspace python install cmem-plugin-sparql-anything
  ```


pkgId: a4af3fa4a4d5bb9b7beb7e2bf41454d0201018eab92b9f6f2c692951dfe3f15b
name: python-cmem-plugin-sparql-anything
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Query anything with SPARQL to construct Knowledge Graphs.
url: https://github.com/eccenca/cmem-plugin-sparql-anything
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmem-plugin-sparql-anything-0.5.0-1.src.rpm
checksum_type: sha256
description:
  Query anything with SPARQL to construct Knowledge Graphs.

  This is a plugin for [eccenca](https://eccenca.com) [Corporate Memory](https://documentation.eccenca.com). You can install it with the [cmemc](https://eccenca.com/go/cmemc) command line clients like this:

  ```
  cmemc admin workspace python install cmem-plugin-sparql-anything
  ```
  [![workflow](https://github.com/eccenca/cmem-plugin-sparql-anything/actions/workflows/check.yml/badge.svg)](https://github.com/eccenca/cmem-plugin-sparql-anything/actions) [![pypi version](https://img.shields.io/pypi/v/cmem-plugin-sparql-anything)](https://pypi.org/project/cmem-plugin-sparql-anything) [![license](https://img.shields.io/pypi/l/cmem-plugin-sparql-anything)](https://pypi.org/project/cmem-plugin-sparql-anything)
  [![poetry][poetry-shield]][poetry-link] [![ruff][ruff-shield]][ruff-link] [![mypy][mypy-shield]][mypy-link] [![copier][copier-shield]][copier]

  [cmem-link]: https://documentation.eccenca.com
  [cmem-shield]: https://img.shields.io/endpoint?url=https://dev.documentation.eccenca.com/badge.json
  [poetry-link]: https://python-poetry.org/
  [poetry-shield]: https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json
  [ruff-link]: https://docs.astral.sh/ruff/
  [ruff-shield]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&label=Code%20Style
  [mypy-link]: https://mypy-lang.org/
  [mypy-shield]: https://www.mypy-lang.org/static/mypy_badge.svg
  [copier]: https://copier.readthedocs.io/
  [copier-shield]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-inverted-border-purple.json


pkgId: 228a82105a9d673a1816552b1b81e758111dfbca2465095d529a27b192c70386
name: python-cmem-plugin-splitfile
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Split a text file into parts of the same filesize
url: https://pypi.org/project/cmem-plugin-splitfile/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmem-plugin-splitfile-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Split a text file into parts with a specified size.

  [![eccenca Corporate Memory][cmem-shield]][cmem-link]

  This is a plugin for [eccenca](https://eccenca.com) [Corporate Memory](https://documentation.eccenca.com). You can install it with the [cmemc](https://eccenca.com/go/cmemc) command line clients like this:

  ```
  cmemc admin workspace python install cmem-plugin-splitfile
  ```





  The input file to be split.
  _Example:_ An input file with the name _input.nt_ will be split into files with the names _input\_000000001.nt_,
  _input\_000000002.nt_,   _input\_000000003.nt_, etc.
  ⚠️ Existing files will be overwritten!



  The maximum size of the chunk files.



  The unit of the size value: kilobyte (KB), megabyte (MB), gigabyte (GB), or number of lines (Lines).



  Include the header in each split. The first line of the input file is treated as the header.



  Delete the input file after splitting.



  Use the internal projects directory of DataIntegration to fetch and store files, instead of using the API.
  If enabled, the "Internal projects directory" parameter has to be set.



  The path to the internal projects directory. If "Use internal projects directory" is disabled,
  this parameter has no effect.


  [![poetry][poetry-shield]][poetry-link] [![ruff][ruff-shield]][ruff-link] [![mypy][mypy-shield]][mypy-link] [![copier][copier-shield]][copier]

  [cmem-link]: https://documentation.eccenca.com
  [cmem-shield]: https://img.shields.io/endpoint?url=https://dev.documentation.eccenca.com/badge.json
  [poetry-link]: https://python-poetry.org/
  [poetry-shield]: https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json
  [ruff-link]: https://docs.astral.sh/ruff/
  [ruff-shield]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&label=Code%20Style
  [mypy-link]: https://mypy-lang.org/
  [mypy-shield]: https://www.mypy-lang.org/static/mypy_badge.svg
  [copier]: https://copier.readthedocs.io/
  [copier-shield]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-inverted-border-purple.json


pkgId: 9d6ef2381b627f6d21761ff7580ea9ed0ea22a16e94448f0b55a179030e69834
name: python-cmem-plugin-validation
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Start and control graph validation processes.
url: https://pypi.org/project/cmem-plugin-validation/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmem-plugin-validation-0.5.0-1.src.rpm
checksum_type: sha256
description:
  Start and control graph validation processes.

  [![eccenca Corporate Memory][cmem-shield]][cmem-link]

  This is a plugin for [eccenca](https://eccenca.com) [Corporate Memory](https://documentation.eccenca.com). You can install it with the [cmemc](https://eccenca.com/go/cmemc) command line clients like this:

  ```
  cmemc admin workspace python install cmem-plugin-validation
  ```

  [![poetry][poetry-shield]][poetry-link] [![ruff][ruff-shield]][ruff-link] [![mypy][mypy-shield]][mypy-link] [![copier][copier-shield]][copier]

  [cmem-link]: https://documentation.eccenca.com
  [cmem-shield]: https://img.shields.io/endpoint?url=https://dev.documentation.eccenca.com/badge.json
  [poetry-link]: https://python-poetry.org/
  [poetry-shield]: https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json
  [ruff-link]: https://docs.astral.sh/ruff/
  [ruff-shield]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&label=Code%20Style
  [mypy-link]: https://mypy-lang.org/
  [mypy-shield]: https://www.mypy-lang.org/static/mypy_badge.svg
  [copier]: https://copier.readthedocs.io/
  [copier-shield]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-inverted-border-purple.json


pkgId: 8fb27b939fddd723de8d1b6fd77fa4a504ac4fa9e7e83313a34896c7b6524d76
name: python-cmem-plugin-validation
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Start and control graph validation processes.
url: https://github.com/eccenca/cmem-plugin-validation
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmem-plugin-validation-1.0.1-1.src.rpm
checksum_type: sha256
description:
  Start and control graph validation processes.

  [![eccenca Corporate Memory][cmem-shield]][cmem-link]

  This is a plugin for [eccenca](https://eccenca.com) [Corporate Memory](https://documentation.eccenca.com). You can install it with the [cmemc](https://eccenca.com/go/cmemc) command line clients like this:

  ```
  cmemc admin workspace python install cmem-plugin-validation
  ```
  [![workflow](https://github.com/eccenca/cmem-plugin-validation/actions/workflows/check.yml/badge.svg)](https://github.com/eccenca/cmem-plugin-validation/actions) [![pypi version](https://img.shields.io/pypi/v/cmem-plugin-validation)](https://pypi.org/project/cmem-plugin-validation) [![license](https://img.shields.io/pypi/l/cmem-plugin-validation)](https://pypi.org/project/cmem-plugin-validation)
  [![poetry][poetry-shield]][poetry-link] [![ruff][ruff-shield]][ruff-link] [![mypy][mypy-shield]][mypy-link] [![copier][copier-shield]][copier]

  [cmem-link]: https://documentation.eccenca.com
  [cmem-shield]: https://img.shields.io/endpoint?url=https://dev.documentation.eccenca.com/badge.json
  [poetry-link]: https://python-poetry.org/
  [poetry-shield]: https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json
  [ruff-link]: https://docs.astral.sh/ruff/
  [ruff-shield]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&label=Code%20Style
  [mypy-link]: https://mypy-lang.org/
  [mypy-shield]: https://www.mypy-lang.org/static/mypy_badge.svg
  [copier]: https://copier.readthedocs.io/
  [copier-shield]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-inverted-border-purple.json


pkgId: 07b98724d086314fecf824f7f7e17b249128f137bef07c3571db639c4c3d22a2
name: python-cmemsapi
arch: src
version: 0.1.17
epoch: 0
release: 1
description: long description
url: https://github.com/copernicusmarine/cmemsapi
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmemsapi-0.1.17-1.src.rpm
checksum_type: sha256
summary:
  A package to help generating reliable data requests about earth observation and marine related information from Copernicus Marine Database.


pkgId: e55fb5806a446c097afaaec8dc6832bf1d438b17193d7747d707ca2332d9dcea
name: python-cmgr
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: A configuratable config manager for your packages.
url: https://github.com/kyan001/PyConfigManager
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmgr-0.2.3-1.src.rpm
checksum_type: sha256
description:
  [CHANGELOG](CHANGELOG.md)

  [cmgr](https://github.com/kyan001/PyConfigManager) is a command-line tool to manage configurations and packages. It's designed to be simple and easy to use. It's written in Python and can be installed via pip and pipx.



  ```sh
  pip install cmgr  # Install cmgr
  cmgr  # Run cmgr. Detect all `cmgr.toml` under current folder.
  ```



  ```sh

  pip install --user cmgr  # install cmgr
  pip install --upgrade cmgr # upgrade cmgr
  pip uninstall cmgr  # uninstall cmgr


  pipx install cmgr  # install cmgr
  pipx upgrade cmgr  # upgrade cmgr
  pipx uninstall cmgr  # uninstall cmgr
  ```



  ```sh

  cmgr --help  # Command-line help message.
  cmgr --version  # Show version information.

  cmgr  # Run cgmr. Will looking for all cmgr.toml under current folder.
  cmgr -p/--profile '/path/to/root/cmgr.toml'  # Run cmgr with specific profile.
  cmgr -r/--root '/path/to/root/'  # Run cmgr with specific root folder.
  cmgr -n/--name 'my-cmgr.toml'  # Run cmgr with specific profile's filename.


  cmgr install ping3  # Install a package named ping3. Using default package manager.
  cmgr install ping3 -c/--command 'ping3'  # Use specific command to detect if the package is installed before install.
  cmgr install ping3 -m/--manager 'pip'  # Use specific package manager to install the package.


  cmgr config "bash.conf" "~/.bashrc"  # Copy `./bash.conf` to `~/.bashrc`.
  cmgr config "bash.conf" "~/.bashrc" -n/--name "BASH"  # Copy `bash.conf` to `~/` as `.bashrc` with specific name in output.
  ```


  * A cmgr profile example: [cmgr-example.toml](cmgr-example.toml)
  * A minimal cmgr profile: [cmgr-minimal.toml](cmgr-minimal.toml)

rpm_license:
  BSD 3-Clause License  Copyright (c) 2024, Kyan  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 68d52ab7fd80a5e5f6f35672c98a2e265f857b683c7dc18d15c26cc7d748086c
name: python-cmi-docx
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: .docx utilities
url: https://pypi.org/project/cmi-docx/
rpm_license: LGPL-2.1
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmi-docx-0.3.4-1.src.rpm
checksum_type: sha256
description:
  [![Build](https://github.com/childmindresearch/cmi-docx/actions/workflows/test.yaml/badge.svg?branch=main)](https://github.com/childmindresearch/cmi-docx/actions/workflows/test.yaml?query=branch%3Amain)
  [![codecov](https://codecov.io/gh/childmindresearch/cmi-docx/branch/main/graph/badge.svg?token=22HWWFWPW5)](https://codecov.io/gh/childmindresearch/cmi-docx)
  [![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)
  ![stability-stable](https://img.shields.io/badge/stability-stable-green.svg)
  [![LGPL--2.1 License](https://img.shields.io/badge/license-LGPL--2.1-blue.svg)](https://github.com/childmindresearch/cmi-docx/blob/main/LICENSE)
  [![pages](https://img.shields.io/badge/api-docs-blue)](https://childmindresearch.github.io/cmi-docx)

  `cmi-docx` is a Python library for manipulating .docx files built on top of `python-docx`. It extends the functionality of `python-docx` by providing additional features and utilities for working with .docx files.



  - Find and replace.
  - Insert paragraphs in the middle of a document.
  - Manipulate styles and formatting of paragraphs' substrings.



  Install this package from pypi using your favorite package manager. For example, using `pip`:

  ```sh
  pip install cmi-docx
  ```



  The following example demonstratesa few features of cmi-docx:

  ```Python
  import docx

  from cmi_docx import document

  doc = docx.Document()
  paragraph = doc.add_paragraph("Hello, world!")
  extend_document = document.ExtendDocument(doc)
  extend_paragraph = document.ExtendParagraph(paragraph)


  extend_document.replace("Hello", "Hi", {"bold": True})


  extend_document.insert_image(index=1, image_path="path/to/image.png")


  extend_paragraph.format(italics=True)
  ```


pkgId: 82e2398c16e3dd67256a320e2a816de3bea238ccfd8cac138a0ec400934b6846
name: python-cmind
arch: src
version: 3.2.6
epoch: 0
release: 1
summary: cmind
url: https://github.com/mlcommons/ck/tree/master/cm
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmind-3.2.6-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/cmind.svg)](https://pepy.tech/project/cmind)
  [![Python Version](https://img.shields.io/badge/python-3+-blue.svg)](https://github.com/mlcommons/ck/tree/master/cm/cmind)
  [![License](https://img.shields.io/badge/License-Apache%202.0-green)](LICENSE.md)
  [![Downloads](https://static.pepy.tech/badge/cmind)](https://pepy.tech/project/cmind)

  [![arXiv](https://img.shields.io/badge/arXiv-2406.16791-b31b1b.svg)](https://arxiv.org/abs/2406.16791)
  [![CM test](https://github.com/mlcommons/ck/actions/workflows/test-cm.yml/badge.svg)](https://github.com/mlcommons/ck/actions/workflows/test-cm.yml)
  [![CM script automation features test](https://github.com/mlcommons/ck/actions/workflows/test-cm-script-features.yml/badge.svg)](https://github.com/mlcommons/ck/actions/workflows/test-cm-script-features.yml)



  Collective Mind (CM) is a small, modular, cross-platform and decentralized workflow automation framework
  with a human-friendly interface to make it easier to build, run, benchmark and optimize applications
  across diverse models, data sets, software and hardware.

  CM is a part of [Collective Knowledge (CK)](https://github.com/mlcommons/ck) -
  an educational community project to learn how to run emerging workloads
  in the most efficient and cost-effective way across diverse
  and continuously changing systems.

  CM includes a collection of portable, extensible and technology-agnostic automation recipes
  with a common API and CLI (aka CM scripts) to unify and automate different steps
  required to compose, run, benchmark and optimize complex ML/AI applications
  on any platform with any software and hardware.

  CM scripts extend the concept of `cmake` with simple Python automations, native scripts
  and JSON/YAML meta descriptions. They require Python 3.7+ with minimal dependencies and are
  [continuously extended by the community and MLCommons members](https://github.com/mlcommons/ck/blob/master/CONTRIBUTING.md)
  to run natively on Ubuntu, MacOS, Windows, RHEL, Debian, Amazon Linux
  and any other operating system, in a cloud or inside automatically generated containers
  while keeping backward compatibility.

  CM scripts were originally developed based on the following requirements from the
  [MLCommons members](https://mlcommons.org)
  to help them automatically compose and optimize complex MLPerf benchmarks, applications and systems
  across diverse and continuously changing models, data sets, software and hardware
  from Nvidia, Intel, AMD, Google, Qualcomm, Amazon and other vendors:
  * must work out of the box with the default options and without the need to edit some paths, environment variables and configuration files;
  * must be non-intrusive, easy to debug and must reuse existing
    user scripts and automation tools (such as cmake, make, ML workflows,
    python poetry and containers) rather than substituting them;
  * must have a very simple and human-friendly command line with a Python API and minimal dependencies;
  * must require minimal or zero learning curve by using plain Python, native scripts, environment variables
    and simple JSON/YAML descriptions instead of inventing new workflow languages;
  * must have the same interface to run all automations natively, in a cloud or inside containers.



  * CM v2.x (stable version 2022-cur): [installation on Linux, Windows, MacOS](https://access.cknowledge.org/playground/?action=install) ;
    [docs](https://docs.mlcommons.org/ck) ; [popular commands](https://github.com/mlcommons/ck/tree/master/cm/docs/demos/some-cm-commands.md) ;
    [getting started guide](https://github.com/mlcommons/ck/blob/master/docs/getting-started.md)
  * CM v3.x (prototype 2024-cur): [docs](https://github.com/mlcommons/ck/tree/master/cm/docs/cmx)
  * MLPerf inference benchmark automated via CM
    * [Run MLPerf for submissions](https://docs.mlcommons.org/inference)
    * [Run MLPerf at the Student Cluster Competition'24](https://docs.mlcommons.org/inference/benchmarks/text_to_image/reproducibility/scc24)
  * Examples of modular containers and GitHub actions with CM commands:
    * [GitHub action with CM commands to test MLPerf inference benchmark](https://github.com/mlcommons/inference/blob/master/.github/workflows/test-bert.yml)
    * [Dockerfile to run MLPerf inference benchmark via CM](https://github.com/mlcommons/ck/blob/master/cm-mlops/script/app-mlperf-inference/dockerfiles/bert-99.9/ubuntu_22.04_python_onnxruntime_cpu.Dockerfile)



  [Apache 2.0](LICENSE.md)



  If you found CM useful, please cite this article:
  [ [ArXiv](https://arxiv.org/abs/2406.16791) ], [ [BibTex](https://github.com/mlcommons/ck/blob/master/citation.bib) ].

  You can learn more about the motivation behind these projects from the following articles and presentations:

  * "Enabling more efficient and cost-effective AI/ML systems with Collective Mind, virtualized MLOps, MLPerf, Collective Knowledge Playground and reproducible optimization tournaments": [ [ArXiv](https://arxiv.org/abs/2406.16791) ]
  * ACM REP'23 keynote about the MLCommons CM automation framework: [ [slides](https://doi.org/10.5281/zenodo.8105339) ]
  * ACM TechTalk'21 about Collective Knowledge project: [ [YouTube](https://www.youtube.com/watch?v=7zpeIVwICa4) ] [ [slides](https://learning.acm.org/binaries/content/assets/leaning-center/webinar-slides/2021/grigorifursin_techtalk_slides.pdf) ]



  The Collective Mind framework (CM) was created by [Grigori Fursin](https://cKnowledge.org/gfursin),
  sponsored by cKnowledge.org and cTuning.org, and donated to MLCommons to benefit everyone.
  Since then, this open-source technology (CM, CM4MLOps, CM4MLPerf, CM4ABTF, CM4Research, etc)
  is being developed as a community effort thanks to all our
  [volunteers, collaborators and contributors](https://github.com/mlcommons/ck/blob/master/CONTRIBUTING.md)!


pkgId: 754126077ff21d889ae093a4f76138d62b3dc9a7d74f2c218ce8ab7edebf731d
name: python-cmind
arch: src
version: 3.4.1
epoch: 0
release: 1
summary: Collective Mind automation framework (CM)
url: https://cKnowledge.org
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmind-3.4.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/cmind.svg)](https://pepy.tech/project/cmind)
  [![Python Version](https://img.shields.io/badge/python-3+-blue.svg)](https://github.com/mlcommons/ck/tree/master/cm/cmind)
  [![License](https://img.shields.io/badge/License-Apache%202.0-green)](LICENSE.md)
  [![Downloads](https://static.pepy.tech/badge/cmind)](https://pepy.tech/project/cmind)

  [![arXiv](https://img.shields.io/badge/arXiv-2406.16791-b31b1b.svg)](https://arxiv.org/abs/2406.16791)
  [![CM test](https://github.com/mlcommons/ck/actions/workflows/test-cm.yml/badge.svg)](https://github.com/mlcommons/ck/actions/workflows/test-cm.yml)
  [![CM script automation features test](https://github.com/mlcommons/ck/actions/workflows/test-cm-script-features.yml/badge.svg)](https://github.com/mlcommons/ck/actions/workflows/test-cm-script-features.yml)



  Collective Mind (CM) is a small, modular, cross-platform and decentralized workflow automation framework
  with a human-friendly interface to make it easier to build, run, benchmark and optimize applications
  across diverse models, data sets, software and hardware.

  CM is a part of [Collective Knowledge (CK)](https://github.com/mlcommons/ck) -
  an educational community project to learn how to run emerging workloads
  in the most efficient and cost-effective way across diverse
  and continuously changing systems.

  CM includes a collection of portable, extensible and technology-agnostic automation recipes
  with a common API and CLI (aka CM scripts) to unify and automate different steps
  required to compose, run, benchmark and optimize complex ML/AI applications
  on any platform with any software and hardware.

  CM scripts extend the concept of `cmake` with simple Python automations, native scripts
  and JSON/YAML meta descriptions. They require Python 3.7+ with minimal dependencies and are
  [continuously extended by the community and MLCommons members](https://github.com/mlcommons/ck/blob/master/CONTRIBUTING.md)
  to run natively on Ubuntu, MacOS, Windows, RHEL, Debian, Amazon Linux
  and any other operating system, in a cloud or inside automatically generated containers
  while keeping backward compatibility.

  CM scripts were originally developed based on the following requirements from the
  [MLCommons members](https://mlcommons.org)
  to help them automatically compose and optimize complex MLPerf benchmarks, applications and systems
  across diverse and continuously changing models, data sets, software and hardware
  from Nvidia, Intel, AMD, Google, Qualcomm, Amazon and other vendors:
  * must work out of the box with the default options and without the need to edit some paths, environment variables and configuration files;
  * must be non-intrusive, easy to debug and must reuse existing
    user scripts and automation tools (such as cmake, make, ML workflows,
    python poetry and containers) rather than substituting them;
  * must have a very simple and human-friendly command line with a Python API and minimal dependencies;
  * must require minimal or zero learning curve by using plain Python, native scripts, environment variables
    and simple JSON/YAML descriptions instead of inventing new workflow languages;
  * must have the same interface to run all automations natively, in a cloud or inside containers.



  * [Grigori Fursin](https://cKnowledge.org/gfursin)



  * CM v2.x (2022-cur) (stable): [installation on Linux, Windows, MacOS](https://access.cknowledge.org/playground/?action=install) ;
    [docs](https://docs.mlcommons.org/ck) ; [popular commands](https://github.com/mlcommons/ck/tree/master/cm/docs/demos/some-cm-commands.md) ;
    [getting started guide](https://github.com/mlcommons/ck/blob/master/docs/getting-started.md)
  * CM v3.x aka CMX (2024-cur) (stable): [docs](https://github.com/orgs/mlcommons/projects/46)
  * MLPerf inference benchmark automated via CM
    * [Run MLPerf for submissions](https://docs.mlcommons.org/inference)
    * [Run MLPerf at the Student Cluster Competition'24](https://docs.mlcommons.org/inference/benchmarks/text_to_image/reproducibility/scc24)
  * Examples of modular containers and GitHub actions with CM commands:
    * [GitHub action with CM commands to test MLPerf inference benchmark](https://github.com/mlcommons/inference/blob/master/.github/workflows/test-bert.yml)
    * [Dockerfile to run MLPerf inference benchmark via CM](https://github.com/mlcommons/ck/blob/master/cm-mlops/script/app-mlperf-inference/dockerfiles/bert-99.9/ubuntu_22.04_python_onnxruntime_cpu.Dockerfile)



  [Apache 2.0](LICENSE.md)



  If you found CM automations useful, please cite this article:
  [ [ArXiv](https://arxiv.org/abs/2406.16791) ], [ [BibTex](https://github.com/mlcommons/ck/blob/master/citation.bib) ].

  You can learn more about the motivation behind these projects from the following presentations:

  * "Enabling more efficient and cost-effective AI/ML systems with Collective Mind, virtualized MLOps, MLPerf, Collective Knowledge Playground and reproducible optimization tournaments": [ [ArXiv](https://arxiv.org/abs/2406.16791) ]
  * ACM REP'23 keynote about the MLCommons CM automation framework: [ [slides](https://doi.org/10.5281/zenodo.8105339) ]
  * ACM TechTalk'21 about Collective Knowledge project: [ [YouTube](https://www.youtube.com/watch?v=7zpeIVwICa4) ] [ [slides](https://learning.acm.org/binaries/content/assets/leaning-center/webinar-slides/2021/grigorifursin_techtalk_slides.pdf) ]



  The Collective Mind automation framework (CM) was created by [Grigori Fursin](https://cKnowledge.org/gfursin),
  sponsored by cKnowledge.org and cTuning.org, and donated to MLCommons to benefit everyone.
  This open-source technology (CM, CM4MLOps, CM4MLPerf, CM4ABTF, CM4Research, etc)
  is being developed as a community effort thanks to all our fantastic
  [volunteers, collaborators and contributors](https://github.com/mlcommons/ck/blob/master/CONTRIBUTING.md)!


pkgId: 48097e8b8fbb3ab24f238445b775760b6722bbbeb466737a6b3bbb66af08adbe
name: python-cmind
arch: src
version: 3.4.3
epoch: 0
release: 1
summary: Collective Mind automation framework (CM)
url: https://cKnowledge.org
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmind-3.4.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/cmind.svg)](https://pepy.tech/project/cmind)
  [![Python Version](https://img.shields.io/badge/python-3+-blue.svg)](https://github.com/mlcommons/ck/tree/master/cm/cmind)
  [![License](https://img.shields.io/badge/License-Apache%202.0-green)](LICENSE.md)
  [![Downloads](https://static.pepy.tech/badge/cmind)](https://pepy.tech/project/cmind)

  [![arXiv](https://img.shields.io/badge/arXiv-2406.16791-b31b1b.svg)](https://arxiv.org/abs/2406.16791)
  [![CM test](https://github.com/mlcommons/ck/actions/workflows/test-cm.yml/badge.svg)](https://github.com/mlcommons/ck/actions/workflows/test-cm.yml)
  [![CM script automation features test](https://github.com/mlcommons/ck/actions/workflows/test-cm-script-features.yml/badge.svg)](https://github.com/mlcommons/ck/actions/workflows/test-cm-script-features.yml)



  Collective Mind (CM) is a small, modular, cross-platform and decentralized workflow automation framework
  with a human-friendly interface to make it easier to build, run, benchmark and optimize applications
  across diverse models, data sets, software and hardware.

  CM is a part of [Collective Knowledge (CK)](https://github.com/mlcommons/ck) -
  an educational community project to learn how to run emerging workloads
  in the most efficient and cost-effective way across diverse
  and continuously changing systems.

  CM includes a collection of portable, extensible and technology-agnostic automation recipes
  with a common API and CLI (aka CM scripts) to unify and automate different steps
  required to compose, run, benchmark and optimize complex ML/AI applications
  on any platform with any software and hardware.

  CM scripts extend the concept of `cmake` with simple Python automations, native scripts
  and JSON/YAML meta descriptions. They require Python 3.7+ with minimal dependencies and are
  [continuously extended by the community and MLCommons members](https://github.com/mlcommons/ck/blob/master/CONTRIBUTING.md)
  to run natively on Ubuntu, MacOS, Windows, RHEL, Debian, Amazon Linux
  and any other operating system, in a cloud or inside automatically generated containers
  while keeping backward compatibility.

  CM scripts were originally developed based on the following requirements from the
  [MLCommons members](https://mlcommons.org)
  to help them automatically compose and optimize complex MLPerf benchmarks, applications and systems
  across diverse and continuously changing models, data sets, software and hardware
  from Nvidia, Intel, AMD, Google, Qualcomm, Amazon and other vendors:
  * must work out of the box with the default options and without the need to edit some paths, environment variables and configuration files;
  * must be non-intrusive, easy to debug and must reuse existing
    user scripts and automation tools (such as cmake, make, ML workflows,
    python poetry and containers) rather than substituting them;
  * must have a very simple and human-friendly command line with a Python API and minimal dependencies;
  * must require minimal or zero learning curve by using plain Python, native scripts, environment variables
    and simple JSON/YAML descriptions instead of inventing new workflow languages;
  * must have the same interface to run all automations natively, in a cloud or inside containers.



  * [Grigori Fursin](https://cKnowledge.org/gfursin)



  * CM v2.x (2022-cur) (stable): [installation on Linux, Windows, MacOS](https://access.cknowledge.org/playground/?action=install) ;
    [docs](https://docs.mlcommons.org/ck) ; [popular commands](https://github.com/mlcommons/ck/tree/master/cm/docs/demos/some-cm-commands.md) ;
    [getting started guide](https://github.com/mlcommons/ck/blob/master/docs/getting-started.md)
  * CM v3.x aka CMX (2024-cur) (stable): [docs](https://github.com/orgs/mlcommons/projects/46)
  * MLPerf inference benchmark automated via CM
    * [Run MLPerf for submissions](https://docs.mlcommons.org/inference)
    * [Run MLPerf at the Student Cluster Competition'24](https://docs.mlcommons.org/inference/benchmarks/text_to_image/reproducibility/scc24)
  * Examples of modular containers and GitHub actions with CM commands:
    * [GitHub action with CM commands to test MLPerf inference benchmark](https://github.com/mlcommons/inference/blob/master/.github/workflows/test-bert.yml)
    * [Dockerfile to run MLPerf inference benchmark via CM](https://github.com/mlcommons/ck/blob/master/cm-mlops/script/app-mlperf-inference/dockerfiles/bert-99.9/ubuntu_22.04_python_onnxruntime_cpu.Dockerfile)



  [Apache 2.0](LICENSE.md)



  If you found CM automations useful, please cite this article:
  [ [ArXiv](https://arxiv.org/abs/2406.16791) ], [ [BibTex](https://github.com/mlcommons/ck/blob/master/citation.bib) ].

  You can learn more about the motivation behind these projects from the following presentations:

  * "Enabling more efficient and cost-effective AI/ML systems with Collective Mind, virtualized MLOps, MLPerf, Collective Knowledge Playground and reproducible optimization tournaments": [ [ArXiv](https://arxiv.org/abs/2406.16791) ]
  * ACM REP'23 keynote about the MLCommons CM automation framework: [ [slides](https://doi.org/10.5281/zenodo.8105339) ]
  * ACM TechTalk'21 about Collective Knowledge project: [ [YouTube](https://www.youtube.com/watch?v=7zpeIVwICa4) ] [ [slides](https://learning.acm.org/binaries/content/assets/leaning-center/webinar-slides/2021/grigorifursin_techtalk_slides.pdf) ]



  The Collective Mind (CM) automation framework was originally
  developed by [Grigori Fursin](https://cKnowledge.org/gfursin),
  as a part of the [Collective Knowledge educational initiative](https://cKnowledge.org),
  sponsored by [cTuning.org](https://cTuning.org) and [cKnowledge.org](https://cKnowledge.org),
  and contributed to MLCommons for the benefit of all.
  This open-source technology, including CM4MLOps/CM4MLPerf, CM4ABTF, CM4Research, and more,
  is a collaborative community-driven project made possible by our
  [amazing volunteers, collaborators, and contributors](https://github.com/mlcommons/ck/blob/master/CONTRIBUTING.md)!


pkgId: 9dee8155a7a6cc10664b867128d63b5346b8f18702db81043041599f329aad9b
name: python-cmind
arch: src
version: 3.5.1
epoch: 0
release: 1
summary: Collective Mind automation framework (CM)
url: https://cKnowledge.org
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cmind-3.5.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/cmind.svg)](https://pepy.tech/project/cmind)
  [![Python Version](https://img.shields.io/badge/python-3+-blue.svg)](https://github.com/mlcommons/ck/tree/master/cm/cmind)
  [![License](https://img.shields.io/badge/License-Apache%202.0-green)](LICENSE.md)
  [![Downloads](https://static.pepy.tech/badge/cmind)](https://pepy.tech/project/cmind)

  [![arXiv](https://img.shields.io/badge/arXiv-2406.16791-b31b1b.svg)](https://arxiv.org/abs/2406.16791)
  [![CM test](https://github.com/mlcommons/ck/actions/workflows/test-cm.yml/badge.svg)](https://github.com/mlcommons/ck/actions/workflows/test-cm.yml)
  [![CM script automation features test](https://github.com/mlcommons/ck/actions/workflows/test-cm-script-features.yml/badge.svg)](https://github.com/mlcommons/ck/actions/workflows/test-cm-script-features.yml)



  Collective Mind (CM) is a very lightweight [Python-based framework](https://github.com/mlcommons/ck/tree/master/cm)
  featuring a unified CLI, Python API, and minimal dependencies. It is available through [PYPI](https://pypi.org/project/cmind).

  CM is designed for creating and managing portable and technology-agnostic automations for MLOps, DevOps and ResearchOps.
  It aims to assist researchers and engineers in automating their repetitive, tedious and time-consuming tasks
  to build, run, benchmark and optimize various applications
  across diverse and continuously changing models, data, software and hardware.

  Collective Mind is a part of [Collective Knowledge (CK)](https://github.com/mlcommons/ck) -
  an educational community project to learn how to run AI, ML and other emerging workloads
  in the most efficient and cost-effective way across diverse
  and ever-evolving systems using the MLPerf benchmarking methodology.



  The diagram below illustrates the primary classes, functions, and internal automations within the Collective Mind framework:

  ![](https://github.com/mlcommons/ck/tree/master/docs/specs/cm-diagram-v3.5.1.png)

  The CM API documentation is available [here](https://cknowledge.org/docs/cm/api/cmind.html).



  Collective Mind is continuously enhanced through public and private CM4* Git repositories,
  which serve as the unified interface for various collections of reusable automations and artifacts.

  The most notable projects and repositories powered by CM are:



  [CM4MLOPS repository powered by CM](https://github.com/mlcommons/cm4mlops) -
  a collection of portable, extensible and technology-agnostic automation recipes
  with a common CLI and Python API (CM scripts) to unify and automate
  all the manual steps required to compose, run, benchmark and optimize complex ML/AI applications
  on diverse platforms with any software and hardware.

  The two key automations are *script" and *cache*:
  see [online catalog at CK playground](https://access.cknowledge.org/playground/?action=scripts),
  [online MLCommons catalog](https://docs.mlcommons.org/cm4mlops/scripts).

  CM scripts extend the concept of `cmake` with simple Python automations, native scripts
  and JSON/YAML meta descriptions. They require Python 3.7+ with minimal dependencies and are
  [continuously extended by the community and MLCommons members](https://github.com/mlcommons/ck/blob/master/CONTRIBUTING.md)
  to run natively on Ubuntu, MacOS, Windows, RHEL, Debian, Amazon Linux
  and any other operating system, in a cloud or inside automatically generated containers
  while keeping backward compatibility.

  CM scripts were originally developed based on the following requirements from the
  [MLCommons members](https://mlcommons.org)
  to help them automatically compose and optimize complex MLPerf benchmarks, applications and systems
  across diverse and continuously changing models, data sets, software and hardware
  from Nvidia, Intel, AMD, Google, Qualcomm, Amazon and other vendors:
  * must work out of the box with the default options and without the need to edit some paths, environment variables and configuration files;
  * must be non-intrusive, easy to debug and must reuse existing
    user scripts and automation tools (such as cmake, make, ML workflows,
    python poetry and containers) rather than substituting them;
  * must have a very simple and human-friendly command line with a Python API and minimal dependencies;
  * must require minimal or zero learning curve by using plain Python, native scripts, environment variables
    and simple JSON/YAML descriptions instead of inventing new workflow languages;
  * must have the same interface to run all automations natively, in a cloud or inside containers.

  See the [online documentation](https://docs.mlcommons.org/inference)
  at MLCommons to run MLPerf inference benchmarks across diverse systems using CM.



  [CM4ABTF repository powered by CM](https://github.com/mlcommons/cm4abtf) -
  a collection of portable automations and CM scripts to run the upcoming
  automotive MLPerf benchmark across different models, data sets, software
  and hardware from different vendors.



  [CM4MLPerf-results powered by CM](https://github.com/mlcommons/cm4mlperf-results) -
  a simplified and unified representation of the past MLPerf results
  in the CM format for further visualization and analysis using [CK graphs](https://access.cknowledge.org/playground/?action=experiments).



  [CM4Research repository powered by CM](https://github.com/ctuning/cm4research) -
  a unified interface designed to streamline the preparation, execution, and reproduction of experiments in research projects.






  [Collective Knowledge Playground](https://access.cKnowledge.org) -
  a unified and open-source platform designed to [index all CM scripts](https://access.cknowledge.org/playground/?action=scripts) similar to PYPI,
  assist users in preparing CM commands to:

  * [run MLPerf benchmarks](https://access.cknowledge.org/playground/?action=howtorun)
  * aggregate, process, visualize, and compare [benchmarking results](https://access.cknowledge.org/playground/?action=experiments) for AI and ML systems
  * organize [open, reproducible optimization challenges and tournaments](https://access.cknowledge.org/playground/?action=challenges).

  These initiatives aim to help academia and industry
  collaboratively enhance the efficiency and cost-effectiveness of AI systems.



  [Artifact Evaluation automation](https://cTuning.org/ae) - a community-driven initiative
  leveraging the Collective Mind framework to automate artifact evaluation
  and support reproducibility efforts at ML and systems conferences.

  CM scripts extend the concept of `cmake` with simple Python automations, native scripts
  and JSON/YAML meta descriptions. They require Python 3.7+ with minimal dependencies and are
  [continuously extended by the community and MLCommons members](https://github.com/mlcommons/ck/blob/master/CONTRIBUTING.md)
  to run natively on Ubuntu, MacOS, Windows, RHEL, Debian, Amazon Linux
  and any other operating system, in a cloud or inside automatically generated containers
  while keeping backward compatibility.

  CM scripts were originally developed based on the following requirements from the
  [MLCommons members](https://mlcommons.org)
  to help them automatically compose and optimize complex MLPerf benchmarks, applications and systems
  across diverse and continuously changing models, data sets, software and hardware
  from Nvidia, Intel, AMD, Google, Qualcomm, Amazon and other vendors:
  * must work out of the box with the default options and without the need to edit some paths, environment variables and configuration files;
  * must be non-intrusive, easy to debug and must reuse existing
    user scripts and automation tools (such as cmake, make, ML workflows,
    python poetry and containers) rather than substituting them;
  * must have a very simple and human-friendly command line with a Python API and minimal dependencies;
  * must require minimal or zero learning curve by using plain Python, native scripts, environment variables
    and simple JSON/YAML descriptions instead of inventing new workflow languages;
  * must have the same interface to run all automations natively, in a cloud or inside containers.



  * [Grigori Fursin](https://cKnowledge.org/gfursin) (FlexAI, cTuning)



  * [CM4MLOPS / CM4MLPerf](https://github.com/mlcommons/cm4mlops) -
    a collection of portable, extensible and technology-agnostic automation recipes
    with a common CLI and Python API (CM scripts) to unify and automate
    all the manual steps required to compose, run, benchmark and optimize complex ML/AI applications
    on diverse platforms with any software and hardware: see [online catalog at CK playground](https://access.cknowledge.org/playground/?action=scripts),
    [online MLCommons catalog](https://docs.mlcommons.org/cm4mlops/scripts)

  * [CM interface to run MLPerf inference benchmarks](https://docs.mlcommons.org/inference)

  * [CM4ABTF](https://github.com/mlcommons/cm4abtf) - a unified CM interface and automation recipes
    to run automotive benchmark across different models, data sets, software and hardware from different vendors.

  * [CM4Research](https://github.com/ctuning/cm4research) - a unified CM interface an automation recipes
    to make it easier to reproduce results from published research papers.




  * CM v2.x (2022-cur) (stable): [installation on Linux, Windows, MacOS](https://access.cknowledge.org/playground/?action=install) ;
    [docs](https://docs.mlcommons.org/ck) ; [popular commands](https://github.com/mlcommons/ck/tree/master/cm/docs/demos/some-cm-commands.md) ;
    [getting started guide](https://github.com/mlcommons/ck/blob/master/docs/getting-started.md)
  * CM v3.x aka CMX (2024-cur) (stable): [docs](https://github.com/orgs/mlcommons/projects/46)
  * MLPerf inference benchmark automated via CM
    * [Run MLPerf for submissions](https://docs.mlcommons.org/inference)
    * [Run MLPerf at the Student Cluster Competition'24](https://docs.mlcommons.org/inference/benchmarks/text_to_image/reproducibility/scc24)
  * Examples of modular containers and GitHub actions with CM commands:
    * [GitHub action with CM commands to test MLPerf inference benchmark](https://github.com/mlcommons/inference/blob/master/.github/workflows/test-bert.yml)
    * [Dockerfile to run MLPerf inference benchmark via CM](https://github.com/mlcommons/ck/blob/master/cm-mlops/script/app-mlperf-inference/dockerfiles/bert-99.9/ubuntu_22.04_python_onnxruntime_cpu.Dockerfile)



  [Apache 2.0](LICENSE.md)



  If you found CM automations, please cite this article:
  [ [ArXiv](https://arxiv.org/abs/2406.16791) ], [ [BibTex](https://github.com/mlcommons/ck/blob/master/citation.bib) ].

  You can learn more about the motivation behind these projects from the following presentations:

  * "Enabling more efficient and cost-effective AI/ML systems with Collective Mind, virtualized MLOps, MLPerf, Collective Knowledge Playground and reproducible optimization tournaments": [ [ArXiv](https://arxiv.org/abs/2406.16791) ]
  * ACM REP'23 keynote about the MLCommons CM automation framework: [ [slides](https://doi.org/10.5281/zenodo.8105339) ]
  * ACM TechTalk'21 about Collective Knowledge project: [ [YouTube](https://www.youtube.com/watch?v=7zpeIVwICa4) ] [ [slides](https://learning.acm.org/binaries/content/assets/leaning-center/webinar-slides/2021/grigorifursin_techtalk_slides.pdf) ]



  Collective Mind (CM) was originally developed by [Grigori Fursin](https://cKnowledge.org/gfursin),
  as a part of the [Collective Knowledge educational initiative](https://cKnowledge.org),
  sponsored by [cTuning.org](https://cTuning.org) and [cKnowledge.org](https://cKnowledge.org),
  and contributed to MLCommons for the benefit of all.

  This open-source technology, including CM4MLOps/CM4MLPerf, CM4ABTF, CM4Research, and more,
  is a collaborative project supported by [MLCommons](https://mlcommons.org),
  [FlexAI](https://flex.ai), [cTuning](https://cTuning.org)
  and our [amazing volunteers, collaborators, and contributors](https://github.com/mlcommons/ck/blob/master/CONTRIBUTING.md)!


