# packages

pkgId: e8440cbe842c5e2e70959ad8a8f8a09af29a9dbcd11d60d0dda3dc1ccc5bb631
name: python-ctREFPROP
arch: noarch
version: 0.10.4
epoch: 0
release: 1
summary: A ctypes wrapper for NIST REFPROP library
url: https://pypi.org/project/ctREFPROP/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ctREFPROP-0.10.4-1.src.rpm
location_href: Packages/python-ctREFPROP-0.10.4-1.noarch.rpm
checksum_type: sha256
rpm_license:
  # NIST Software Licensing Statement  NIST-developed software is provided by NIST as a public service. You may use, copy, and distribute copies of the software in any medium, provided that you keep intact this entire notice. You may improve, modify, and create derivative works of the software or any portion of the software, and you may copy and distribute such modifications or works. Modified works should carry a notice stating that you changed the software and should note the date and nature of any such change. Please explicitly acknowledge the National Institute of Standards and Technology as the source of the software.  NIST-developed software is expressly provided "AS IS." NIST MAKES NO WARRANTY OF ANY KIND, EXPRESS, IMPLIED, IN FACT, OR ARISING BY OPERATION OF LAW, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND DATA ACCURACY. NIST NEITHER REPRESENTS NOR WARRANTS THAT THE OPERATION OF THE SOFTWARE WILL BE UNINTERRUPTED OR ERROR-FREE, OR THAT ANY DEFECTS WILL BE CORRECTED. NIST DOES NOT WARRANT OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF THE SOFTWARE OR THE RESULTS THEREOF, INCLUDING BUT NOT LIMITED TO THE CORRECTNESS, ACCURACY, RELIABILITY, OR USEFULNESS OF THE SOFTWARE.  You are solely responsible for determining the appropriateness of using and distributing the software and you assume all risks associated with its use, including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and the unavailability or interruption of operation. This software is not intended to be used in any situation where a failure could cause risk of injury or damage to property. The software developed by NIST employees is not subject to copyright protection within the United States.


pkgId: e975423ae6dbcb1eea9bf4842d39048dfd2d2b858f2a14c00fbdd59a797a1b79
name: python-ctbl-cylon-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for ctbl-cylon
url: https://pypi.org/project/ctbl-cylon/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ctbl-cylon-0.0.5-1.src.rpm
location_href: Packages/python-ctbl-cylon-help-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
  This is a testing package for personal use. Use it at your own risk.

  The problem: frequently, after creating a new machine, I have to set up a sort-of service account
  to let me do things, like updating stuff, develop, install packages, etc. The process of creating
  these accounts becomes tedious. What if we could just treat these profiles as regular git repos,
  that could be downloaded as required?

  cylon is a script that helps to ease this process. Documentation will be put here as the script
  becomes developed and stable.


pkgId: 4e3694d1f861b1215ce348c9bb5c6ed85e81417b3591fa2c4c65117ef0250b08
name: python-ctbl-tools-help
arch: noarch
version: 0.1.8
epoch: 0
release: 1
summary: Development documents and examples for ctbl-tools
url: https://pypi.org/project/ctbl-tools/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ctbl-tools-0.1.8-1.src.rpm
location_href: Packages/python-ctbl-tools-help-0.1.8-1.noarch.rpm
checksum_type: sha256
description:
  A package with miscelaneous classes meant to help at coding console helpers. Currently there are three classes:

  1. **config**: it implements a config file that saves itself. It is a specialization of [configparser](https://docs.python.org/3/library/configparser.html).
  2. **process**: it runs external processes, it saves the return code, and it helps (a little bit) to parse the standard output (or the standard error).
  3. **git**: a simple interface for git commands.



  It implements a config file that saves itself.

  The idea is: we want to use a config file for an application, which is a simple text file that contains pairs of values, in a similar fashion to an INI file. If the file exists, it is used; if it doesn't, it is created. We use [configparser](https://docs.python.org/3/library/configparser.html) for this.

  An example:

  ```python
  from ctbl_tools.config import config

  cfg = config(initpath = '~/somewhere/blabla.ini')
  cfg.create_section('my_configuration')
  cfg.set('my_configuration', 'x', 1)
  cfg.set('my_configuration', 'y', '2')
  ```

  When the program above ends, it will save all created configuration to the file ~/somewhere/blabla.ini.



  It runs an external program, and it stores the return code and both the standard output and standard error.

  You first create an object of this type:
  ```python
  p = process()
  ```

  Then run a command:
  ```python
  p.run("whoami")
  ```

  Immediately after you gain access to the return code, stdout and stderr:
  ```python
  print(p.returncode)
  for line in p.stdout:
    print(line)
  ```

  You may check if return code was 0 (i.e., all good) by checking `p.is_ok()` to be true. You may also check whether there is any stdout or any stderr with `p.is_there_stdout()` and with `p.is_there_stderr()`, respectively.

  Finally you may extract information out of stdout by using `extract()`. This method receives a regular expression and a boolean that is true by default (meaning that you want to inspect stdout; if false it will inspect stderr instead). The method will look for all matches in each line of stdout and store them in a list. The list stores as many elements as lines stdout has, and each element is a list of all matches within the corresponding line.



  It provides a simple programmatical interface to git.

  First, you create a git object by providing a local path to a repo:

  ```python
  from ctbl_tools.git import git

  x = git("~/Dev/my_repo")
  ```
  The previous will fail if provided path is not a git repo.

  Then you may either get the remote urls with `x.get_remote()`, or a get the status of the working tree by invoking `x.get_status()`.

  You may also do a commit with a list of files with `x.commit(list-of-files)`, or do a push (`x.git_push('my-commit-message')`) or a pull (`x.git_pull()`).

  This package also includes two auxiliary functions:

  * `git_clone(url:str, path:str)`: It clones `url` into `path`.
  * `is_git_url(url:str)`: It checks whether `url` is a valid git url.


pkgId: 0636f77837cab3656882abd4f64af899cac99da88da96788a013c3eea6e5147f
name: python-ctypesForFortran
arch: noarch
version: 2.0.1
epoch: 0
release: 1
summary: Bindings to Fortran subroutines using ctypes
url: https://pypi.org/project/ctypesForFortran/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ctypesForFortran-2.0.1-1.src.rpm
location_href: Packages/python-ctypesForFortran-2.0.1-1.noarch.rpm
checksum_type: sha256
rpm_license:
  CeCILL-C FREE SOFTWARE LICENSE AGREEMENT   Notice  This Agreement is a Free Software license agreement that is the result of discussions between its authors in order to ensure compliance with the two main principles guiding its drafting:  * firstly, compliance with the principles governing the distribution of Free Software: access to source code, broad rights granted to users, * secondly, the election of a governing law, French law, with which it is conformant, both as regards the law of torts and intellectual property law, and the protection that it offers to both authors and holders of the economic rights over software.  The authors of the CeCILL-C (for Ce[a] C[nrs] I[nria] L[ogiciel] L[ibre]) license are:  Commissariat à l'Energie Atomique - CEA, a public scientific, technical and industrial research establishment, having its principal place of business at 25 rue Leblanc, immeuble Le Ponant D, 75015 Paris, France.  Centre National de la Recherche Scientifique - CNRS, a public scientific and technological establishment, having its principal place of business at 3 rue Michel-Ange, 75794 Paris cedex 16, France.  Institut National de Recherche en Informatique et en Automatique - INRIA, a public scientific and technological establishment, having its principal place of business at Domaine de Voluceau, Rocquencourt, BP 105, 78153 Le Chesnay cedex, France.   Preamble  The purpose of this Free Software license agreement is to grant users the right to modify and re-use the software governed by this license.  The exercising of this right is conditional upon the obligation to make available to the community the modifications made to the source code of the software so as to contribute to its evolution.  In consideration of access to the source code and the rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors only have limited liability.  In this respect, the risks associated with loading, using, modifying and/or developing or reproducing the software by the user are brought to the user's attention, given its Free Software status, which may make it complicated to use, with the result that its use is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the suitability of the software as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions of security. This Agreement may be freely reproduced and published, provided it is not altered, and that no provisions are either added or removed herefrom.  This Agreement may apply to any or all software for which the holder of the economic rights decides to submit the use thereof to its provisions.   Article 1 - DEFINITIONS  For the purpose of this Agreement, when the following expressions commence with a capital letter, they shall have the following meaning:  Agreement: means this license agreement, and its possible subsequent versions and annexes.  Software: means the software in its Object Code and/or Source Code form and, where applicable, its documentation, "as is" when the Licensee accepts the Agreement.  Initial Software: means the Software in its Source Code and possibly its Object Code form and, where applicable, its documentation, "as is" when it is first distributed under the terms and conditions of the Agreement.  Modified Software: means the Software modified by at least one Integrated Contribution.  Source Code: means all the Software's instructions and program lines to which access is required so as to modify the Software.  Object Code: means the binary files originating from the compilation of the Source Code.  Holder: means the holder(s) of the economic rights over the Initial Software.  Licensee: means the Software user(s) having accepted the Agreement.  Contributor: means a Licensee having made at least one Integrated Contribution.  Licensor: means the Holder, or any other individual or legal entity, who distributes the Software under the Agreement.  Integrated Contribution: means any or all modifications, corrections, translations, adaptations and/or new functions integrated into the Source Code by any or all Contributors.  Related Module: means a set of sources files including their documentation that, without modification to the Source Code, enables supplementary functions or services in addition to those offered by the Software.  Derivative Software: means any combination of the Software, modified or not, and of a Related Module.  Parties: mean both the Licensee and the Licensor.  These expressions may be used both in singular and plural form.   Article 2 - PURPOSE  The purpose of the Agreement is the grant by the Licensor to the Licensee of a non-exclusive, transferable and worldwide license for the Software as set forth in Article 5 hereinafter for the whole term of the protection granted by the rights over said Software.   Article 3 - ACCEPTANCE  3.1 The Licensee shall be deemed as having accepted the terms and conditions of this Agreement upon the occurrence of the first of the following events:  * (i) loading the Software by any or all means, notably, by downloading from a remote server, or by loading from a physical medium; * (ii) the first time the Licensee exercises any of the rights granted hereunder.  3.2 One copy of the Agreement, containing a notice relating to the characteristics of the Software, to the limited warranty, and to the fact that its use is restricted to experienced users has been provided to the Licensee prior to its acceptance as set forth in Article 3.1 hereinabove, and the Licensee hereby acknowledges that it has read and understood it.   Article 4 - EFFECTIVE DATE AND TERM   4.1 EFFECTIVE DATE  The Agreement shall become effective on the date when it is accepted by the Licensee as set forth in Article 3.1.   4.2 TERM  The Agreement shall remain in force for the entire legal term of protection of the economic rights over the Software.   Article 5 - SCOPE OF RIGHTS GRANTED  The Licensor hereby grants to the Licensee, who accepts, the following rights over the Software for any or all use, and for the term of the Agreement, on the basis of the terms and conditions set forth hereinafter.  Besides, if the Licensor owns or comes to own one or more patents protecting all or part of the functions of the Software or of its components, the Licensor undertakes not to enforce the rights granted by these patents against successive Licensees using, exploiting or modifying the Software. If these patents are transferred, the Licensor undertakes to have the transferees subscribe to the obligations set forth in this paragraph.   5.1 RIGHT OF USE  The Licensee is authorized to use the Software, without any limitation as to its fields of application, with it being hereinafter specified that this comprises:  1. permanent or temporary reproduction of all or part of the Software by any or all means and in any or all form.  2. loading, displaying, running, or storing the Software on any or all medium.  3. entitlement to observe, study or test its operation so as to determine the ideas and principles behind any or all constituent elements of said Software. This shall apply when the Licensee carries out any or all loading, displaying, running, transmission or storage operation as regards the Software, that it is entitled to carry out hereunder.   5.2 RIGHT OF MODIFICATION  The right of modification includes the right to translate, adapt, arrange, or make any or all modifications to the Software, and the right to reproduce the resulting software. It includes, in particular, the right to create a Derivative Software.  The Licensee is authorized to make any or all modification to the Software provided that it includes an explicit notice that it is the author of said modification and indicates the date of the creation thereof.   5.3 RIGHT OF DISTRIBUTION  In particular, the right of distribution includes the right to publish, transmit and communicate the Software to the general public on any or all medium, and by any or all means, and the right to market, either in consideration of a fee, or free of charge, one or more copies of the Software by any means.  The Licensee is further authorized to distribute copies of the modified or unmodified Software to third parties according to the terms and conditions set forth hereinafter.   5.3.1 DISTRIBUTION OF SOFTWARE WITHOUT MODIFICATION  The Licensee is authorized to distribute true copies of the Software in Source Code or Object Code form, provided that said distribution complies with all the provisions of the Agreement and is accompanied by:  1. a copy of the Agreement,  2. a notice relating to the limitation of both the Licensor's warranty and liability as set forth in Articles 8 and 9,  and that, in the event that only the Object Code of the Software is redistributed, the Licensee allows effective access to the full Source Code of the Software at a minimum during the entire period of its distribution of the Software, it being understood that the additional cost of acquiring the Source Code shall not exceed the cost of transferring the data.   5.3.2 DISTRIBUTION OF MODIFIED SOFTWARE  When the Licensee makes an Integrated Contribution to the Software, the terms and conditions for the distribution of the resulting Modified Software become subject to all the provisions of this Agreement.  The Licensee is authorized to distribute the Modified Software, in source code or object code form, provided that said distribution complies with all the provisions of the Agreement and is accompanied by:  1. a copy of the Agreement,  2. a notice relating to the limitation of both the Licensor's warranty and liability as set forth in Articles 8 and 9,  and that, in the event that only the object code of the Modified Software is redistributed, the Licensee allows effective access to the full source code of the Modified Software at a minimum during the entire period of its distribution of the Modified Software, it being understood that the additional cost of acquiring the source code shall not exceed the cost of transferring the data.   5.3.3 DISTRIBUTION OF DERIVATIVE SOFTWARE  When the Licensee creates Derivative Software, this Derivative Software may be distributed under a license agreement other than this Agreement, subject to compliance with the requirement to include a notice concerning the rights over the Software as defined in Article 6.4. In the event the creation of the Derivative Software required modification of the Source Code, the Licensee undertakes that:  1. the resulting Modified Software will be governed by this Agreement, 2. the Integrated Contributions in the resulting Modified Software will be clearly identified and documented, 3. the Licensee will allow effective access to the source code of the Modified Software, at a minimum during the entire period of distribution of the Derivative Software, such that such modifications may be carried over in a subsequent version of the Software; it being understood that the additional cost of purchasing the source code of the Modified Software shall not exceed the cost of transferring the data.   5.3.4 COMPATIBILITY WITH THE CeCILL LICENSE  When a Modified Software contains an Integrated Contribution subject to the CeCILL license agreement, or when a Derivative Software contains a Related Module subject to the CeCILL license agreement, the provisions set forth in the third item of Article 6.4 are optional.   Article 6 - INTELLECTUAL PROPERTY   6.1 OVER THE INITIAL SOFTWARE  The Holder owns the economic rights over the Initial Software. Any or all use of the Initial Software is subject to compliance with the terms and conditions under which the Holder has elected to distribute its work and no one shall be entitled to modify the terms and conditions for the distribution of said Initial Software.  The Holder undertakes that the Initial Software will remain ruled at least by this Agreement, for the duration set forth in Article 4.2.   6.2 OVER THE INTEGRATED CONTRIBUTIONS  The Licensee who develops an Integrated Contribution is the owner of the intellectual property rights over this Contribution as defined by applicable law.   6.3 OVER THE RELATED MODULES  The Licensee who develops a Related Module is the owner of the intellectual property rights over this Related Module as defined by applicable law and is free to choose the type of agreement that shall govern its distribution under the conditions defined in Article 5.3.3.   6.4 NOTICE OF RIGHTS  The Licensee expressly undertakes:  1. not to remove, or modify, in any manner, the intellectual property notices attached to the Software;  2. to reproduce said notices, in an identical manner, in the copies of the Software modified or not;  3. to ensure that use of the Software, its intellectual property notices and the fact that it is governed by the Agreement is indicated in a text that is easily accessible, specifically from the interface of any Derivative Software.  The Licensee undertakes not to directly or indirectly infringe the intellectual property rights of the Holder and/or Contributors on the Software and to take, where applicable, vis-à-vis its staff, any and all measures required to ensure respect of said intellectual property rights of the Holder and/or Contributors.   Article 7 - RELATED SERVICES  7.1 Under no circumstances shall the Agreement oblige the Licensor to provide technical assistance or maintenance services for the Software.  However, the Licensor is entitled to offer this type of services. The terms and conditions of such technical assistance, and/or such maintenance, shall be set forth in a separate instrument. Only the Licensor offering said maintenance and/or technical assistance services shall incur liability therefor.  7.2 Similarly, any Licensor is entitled to offer to its licensees, under its sole responsibility, a warranty, that shall only be binding upon itself, for the redistribution of the Software and/or the Modified Software, under terms and conditions that it is free to decide. Said warranty, and the financial terms and conditions of its application, shall be subject of a separate instrument executed between the Licensor and the Licensee.   Article 8 - LIABILITY  8.1 Subject to the provisions of Article 8.2, the Licensee shall be entitled to claim compensation for any direct loss it may have suffered from the Software as a result of a fault on the part of the relevant Licensor, subject to providing evidence thereof.  8.2 The Licensor's liability is limited to the commitments made under this Agreement and shall not be incurred as a result of in particular: (i) loss due the Licensee's total or partial failure to fulfill its obligations, (ii) direct or consequential loss that is suffered by the Licensee due to the use or performance of the Software, and (iii) more generally, any consequential loss. In particular the Parties expressly agree that any or all pecuniary or business loss (i.e. loss of data, loss of profits, operating loss, loss of customers or orders, opportunity cost, any disturbance to business activities) or any or all legal proceedings instituted against the Licensee by a third party, shall constitute consequential loss and shall not provide entitlement to any or all compensation from the Licensor.   Article 9 - WARRANTY  9.1 The Licensee acknowledges that the scientific and technical state-of-the-art when the Software was distributed did not enable all possible uses to be tested and verified, nor for the presence of possible defects to be detected. In this respect, the Licensee's attention has been drawn to the risks associated with loading, using, modifying and/or developing and reproducing the Software which are reserved for experienced users.  The Licensee shall be responsible for verifying, by any or all means, the suitability of the product for its requirements, its good working order, and for ensuring that it shall not cause damage to either persons or properties.  9.2 The Licensor hereby represents, in good faith, that it is entitled to grant all the rights over the Software (including in particular the rights set forth in Article 5).  9.3 The Licensee acknowledges that the Software is supplied "as is" by the Licensor without any other express or tacit warranty, other than that provided for in Article 9.2 and, in particular, without any warranty as to its commercial value, its secured, safe, innovative or relevant nature.  Specifically, the Licensor does not warrant that the Software is free from any error, that it will operate without interruption, that it will be compatible with the Licensee's own equipment and software configuration, nor that it will meet the Licensee's requirements.  9.4 The Licensor does not either expressly or tacitly warrant that the Software does not infringe any third party intellectual property right relating to a patent, software or any other property right. Therefore, the Licensor disclaims any and all liability towards the Licensee arising out of any or all proceedings for infringement that may be instituted in respect of the use, modification and redistribution of the Software. Nevertheless, should such proceedings be instituted against the Licensee, the Licensor shall provide it with technical and legal assistance for its defense. Such technical and legal assistance shall be decided on a case-by-case basis between the relevant Licensor and the Licensee pursuant to a memorandum of understanding. The Licensor disclaims any and all liability as regards the Licensee's use of the name of the Software. No warranty is given as regards the existence of prior rights over the name of the Software or as regards the existence of a trademark.   Article 10 - TERMINATION  10.1 In the event of a breach by the Licensee of its obligations hereunder, the Licensor may automatically terminate this Agreement thirty (30) days after notice has been sent to the Licensee and has remained ineffective.  10.2 A Licensee whose Agreement is terminated shall no longer be authorized to use, modify or distribute the Software. However, any licenses that it may have granted prior to termination of the Agreement shall remain valid subject to their having been granted in compliance with the terms and conditions hereof.   Article 11 - MISCELLANEOUS   11.1 EXCUSABLE EVENTS  Neither Party shall be liable for any or all delay, or failure to perform the Agreement, that may be attributable to an event of force majeure, an act of God or an outside cause, such as defective functioning or interruptions of the electricity or telecommunications networks, network paralysis following a virus attack, intervention by government authorities, natural disasters, water damage, earthquakes, fire, explosions, strikes and labor unrest, war, etc.  11.2 Any failure by either Party, on one or more occasions, to invoke one or more of the provisions hereof, shall under no circumstances be interpreted as being a waiver by the interested Party of its right to invoke said provision(s) subsequently.  11.3 The Agreement cancels and replaces any or all previous agreements, whether written or oral, between the Parties and having the same purpose, and constitutes the entirety of the agreement between said Parties concerning said purpose. No supplement or modification to the terms and conditions hereof shall be effective as between the Parties unless it is made in writing and signed by their duly authorized representatives.  11.4 In the event that one or more of the provisions hereof were to conflict with a current or future applicable act or legislative text, said act or legislative text shall prevail, and the Parties shall make the necessary amendments so as to comply with said act or legislative text. All other provisions shall remain effective. Similarly, invalidity of a provision of the Agreement, for any reason whatsoever, shall not cause the Agreement as a whole to be invalid.   11.5 LANGUAGE  The Agreement is drafted in both French and English and both versions are deemed authentic.   Article 12 - NEW VERSIONS OF THE AGREEMENT  12.1 Any person is authorized to duplicate and distribute copies of this Agreement.  12.2 So as to ensure coherence, the wording of this Agreement is protected and may only be modified by the authors of the License, who reserve the right to periodically publish updates or new versions of the Agreement, each with a separate number. These subsequent versions may address new issues encountered by Free Software.  12.3 Any Software distributed under a given version of the Agreement may only be subsequently distributed under the same version of the Agreement or a subsequent version.   Article 13 - GOVERNING LAW AND JURISDICTION  13.1 The Agreement is governed by French law. The Parties agree to endeavor to seek an amicable solution to any disagreements or disputes that may arise during the performance of the Agreement.  13.2 Failing an amicable solution within two (2) months as from their occurrence, and unless emergency proceedings are necessary, the disagreements or disputes shall be referred to the Paris Courts having jurisdiction, by the more diligent Party.   Version 1.0 dated 2006-09-05.


pkgId: 479d627590496afe80ae5ad838a69ae99b67494eeb0f8ffc4a0c30cb37bd15b1
name: python-cuallee-help
arch: noarch
version: 0.15.2
epoch: 0
release: 1
summary: Development documents and examples for cuallee
url: https://github.com/canimus/cuallee
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cuallee-0.15.2-1.src.rpm
location_href: Packages/python-cuallee-help-0.15.2-1.noarch.rpm
checksum_type: sha256
description:
  ![snowflake](https://github.com/canimus/cuallee/blob/fbef98f5340279fc726b369a7ce879fd67ea1d1f/logos/snowflake.svg?raw=true "Snowpark DataFrame API")| `snowpark` | `1.11.1`, `1.4.0`
  ![databricks](https://github.com/canimus/cuallee/blob/fbef98f5340279fc726b369a7ce879fd67ea1d1f/logos/databricks.svg?raw=true "PySpark DataFrame API")| `pyspark` & `spark-connect` |`3.5.x`, `3.4.0`, `3.3.x`, `3.2.x`
  ![bigquery](https://github.com/canimus/cuallee/blob/fbef98f5340279fc726b369a7ce879fd67ea1d1f/logos/bigquery.png?raw=true "BigQuery Client API")| `bigquery` | `3.4.1`
  ![pandas](https://github.com/canimus/cuallee/blob/fbef98f5340279fc726b369a7ce879fd67ea1d1f/logos/pandas.svg?raw=true "Pandas DataFrame API")| `pandas`| `2.0.2`, `1.5.x`, `1.4.x`
  ![duckdb](https://github.com/canimus/cuallee/blob/fbef98f5340279fc726b369a7ce879fd67ea1d1f/logos/duckdb.png?raw=true "DuckDB API")|`duckdb` | `1.0.0`, ~~`0.10.2`~~,~~`0.9.2`~~,~~`0.8.0`~~
  ![polars](https://github.com/canimus/cuallee/blob/fbef98f5340279fc726b369a7ce879fd67ea1d1f/logos/polars.svg?raw=true "Polars API")|`polars`| `1.0.0`, ~~`0.19.6`~~
  ![daft](https://github.com/canimus/cuallee/blob/fbef98f5340279fc726b369a7ce879fd67ea1d1f/logos/daft.png?raw=true "Daft API")|`daft`| `0.2.24`, ~~`0.2.19`~~
   <sub>Logos are trademarks of their own brands.</sub>

  ```bash
  pip install cuallee
  ```

  The most common checks for data integrity validations are `completeness` and `uniqueness` an example of this dimensions shown below:
  ```python
  from cuallee import Check, CheckLevel # WARN:0, ERR: 1

  check = Check(CheckLevel.WARNING, "Completeness")
  (
      check
      .is_complete("id")
      .is_unique("id")
      .validate(df)
  ).show() # Returns a pyspark.sql.DataFrame
  ```
  >[!IMPORTANT]
  > A new version of the `validate` output is currently under construction.

  Perhaps one of the most useful features of `cuallee` is its extensive number of checks for `Date` and `Timestamp` values. Including, validation of ranges, set operations like inclusion, or even a verification that confirms `continuity on dates` using the `is_daily` check function.
  ```python

  check = Check(CheckLevel.WARNING, "CheckIsBetweenDates")
  df = spark.sql(
      """
      SELECT
          explode(
              sequence(
                  to_date('2022-01-01'),
                  to_date('2022-01-10'),
                  interval 1 day)) as date
      """)
  assert (
      check.is_between("date", ("2022-01-01", "2022-01-10"))
      .validate(df)
      .first()
      .status == "PASS"
  )
  ```

  Other common test is the validation of `list of values` as part of the multiple integrity checks required for better quality data.
  ```python
  df = spark.createDataFrame([[1, 10], [2, 15], [3, 17]], ["ID", "value"])
  check = Check(CheckLevel.WARNING, "is_contained_in_number_test")
  check.is_contained_in("value", (10, 15, 20, 25)).validate(df)
  ```

  When it comes to the flexibility of matching, regular expressions are always to the rescue. `cuallee` makes use of the regular expressions to validate that fields of type `String` conform to specific patterns.
  ```python
  df = spark.createDataFrame([[1, "is_blue"], [2, "has_hat"], [3, "is_smart"]], ["ID", "desc"])
  check = Check(CheckLevel.WARNING, "has_pattern_test")
  check.has_pattern("desc", r"^is.*t$") # only match is_smart 33% of rows.
  check.validate(df).first().status == "FAIL"
  ```

  Statistical tests are a great aid for verifying anomalies on data. Here an example that shows that will `PASS` only when `40%` of data is inside the interquartile range
  ```python
  df = spark.range(10)
  check = Check(CheckLevel.WARNING, "IQR_Test")
  check.is_inside_interquartile_range("id", pct=0.4)
  check.validate(df).first().status == "PASS"
  +---+-------------------+-----+-------+------+-----------------------------+-----+----+----------+---------+--------------+------+
  |id |timestamp          |check|level  |column|rule                         |value|rows|violations|pass_rate|pass_threshold|status|
  +---+-------------------+-----+-------+------+-----------------------------+-----+----+----------+---------+--------------+------+
  |1  |2022-10-19 00:09:39|IQR  |WARNING|id    |is_inside_interquartile_range|10000|10  |4         |0.6      |0.4           |PASS  |
  +---+-------------------+-----+-------+------+-----------------------------+-----+----+----------+---------+--------------+------+
  ```

  Besides the common `citizen-like` checks, `cuallee` offers out-of-the-box real-life checks. For example, suppose that you are working __SalesForce__ or __SAP__ environment. Very likely your business processes will be driven by a lifecycle:
  - `Order-To-Cash`
  - `Request-To-Pay`
  - `Inventory-Logistics-Delivery`
  - Others.
   In this scenario, `cuallee` offers the ability that the sequence of events registered over time, are according to a sequence of events, like the example below:
   ```python
  import pyspark.sql.functions as F
  from cuallee import Check, CheckLevel
  data = pd.DataFrame({
      "name":["herminio", "herminio", "virginie", "virginie"],
      "event":["new","active", "new", "active"],
      "date": ["2022-01-01", "2022-01-02", "2022-01-03", "2022-02-04"]}
      )
  df = spark.createDataFrame(data).withColumn("date", F.to_date("date"))


  check = Check(CheckLevel.WARNING, "WorkflowViolations")

  check.has_workflow("name", "event", "date", [("new", "active")], pct=0.5)
  check.validate(df).show(truncate=False)
  +---+-------------------+------------------+-------+-------------------------+------------+--------------------+----+----------+---------+--------------+------+
  |id |timestamp          |check             |level  |column                   |rule        |value               |rows|violations|pass_rate|pass_threshold|status|
  +---+-------------------+------------------+-------+-------------------------+------------+--------------------+----+----------+---------+--------------+------+
  |1  |2022-11-07 23:08:50|WorkflowViolations|WARNING|('name', 'event', 'date')|has_workflow|(('new', 'active'),)|4   |2.0       |0.5      |0.5           |PASS  |
  +---+-------------------+------------------+-------+-------------------------+------------+--------------------+----+----------+---------+--------------+------+
   ```

  `[2024-09-28]` ✨ __New feature!__ Return a simple `true|false` as a unified result for your `check`
  ```python
  import pandas as pd
  from cuallee import Check
  df = pd.DataFrame({"X":[1,2,3]})

  assert Check().is_complete("X").ok(df)
  ```

  Simplify the entire validation of a dataframe in a particular dimension.
  ```python
  import pandas as pd
  from cuallee import Control
  df = pd.DataFrame({"X":[1,2,3], "Y": [10,20,30]})

  Control.completeness(df)
  ```

  In the `test` folder there are `docker` containers with the requirements to match the tests. Also a `perftest.py` available at the root folder for interests.
  ```

  cuallee: ▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇ 162.00
  pydeequ: ▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇ 322.00
  ```

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


pkgId: 80ed9f4db5822b4d140ad26ba580cdc7af21883a9a5560ad5d94f94a6825a9e2
name: python-cubic-bezier-spline-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for cubic-bezier-spline
url: https://pypi.org/project/cubic-bezier-spline/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cubic-bezier-spline-0.6.1-1.src.rpm
location_href: Packages/python-cubic-bezier-spline-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  This package exists mostly to create C2-continuous, non-rational cubic Bezier splines. In other words, this will approximate or interpolate a sequence of points into a sequence of non-rational cubic Bezier curves.

  Should be relatively fast, but this isn't suited for heavy math. This is for taking some points you have and making a nice-looking curve out of them. Specifically, a cubic Bezier spline, which is made from the type of curves used in SVG, fonts, and other vector-base programs. I am only interested in feature requests that directly apply to that purpose. This is not an exercise in completism.



      pip install cubic_bezier_spline



  * Evaluate, differentiate, elevate, and split non-rational Bezier curves of any degree
  * Construct non-rational cubic Bezier splines (open and closed, approximating and interpolating)
  * Evaluate and differentiate non-rational Bezier splines of any degree



  * Work with rational Bezier splines, b-splines, NURBS, or any other generalization of Bezier curves
  * Decrease curve degree
  * Approximate curve intersections
  * Approximate the length of a curve
  * "Stroke" (move left or right) a curve<br/>

  ** much of the "will not" features can be found here: https://github.com/dhermes/bezier



      
      new_open_approximating_spline([(x0, y0), (x1, y1), ...])

      
      new_closed_approximating_spline([(x0, y0), (x1, y1), ...])

      
      new_open_interpolating_spline([(x0, y0), (x1, y1), ...])

      
      new_closed_interpolating_spline([(x0, y0), (x1, y1), ...])

  Any of these will return a BezierSpline object. This object has a some of the usual methods (e.g., elevate, derivative, split) to help find path normals or do some light modeling, but you may be most interested in.

      
      
      spline(time: float)

      
      
      spline.svg_data



  Some of these use double and triple repeated points to create "knots". This isn't a special function, just a feature of Bezier math. The idea is clearer with a picture.

  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="doc/test_knot_dark.png">
    <source media="(prefers-color-scheme: light)" srcset="doc/test_knot_light.png">
    <img alt="knot examples" src="doc/test_knot_dark.png">
  </picture>



  * A Primer on Bezier Curves<br/>
  https://pomax.github.io/bezierinfo/
  * UCLS-Math-149-Mathematics-of-Computer-Graphics-lecture-notes<br/>
  https://www.stkent.com/assets/pdfs/UCLA-Math-149-Mathematics-of-Computer-Graphics-lecture-notes.pdf


pkgId: 3abacdc6c03cb92bc2ea024c1ec49a51f033fee6a7d6e27e1cfef9a9aac3ddc1
name: python-cubicweb-web-help
arch: noarch
version: 1.3.3
epoch: 0
release: 1
summary: Development documents and examples for cubicweb-web
url: https://forge.extranet.logilab.fr/cubicweb/cubes/web
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cubicweb-web-1.3.3-1.src.rpm
location_href: Packages/python-cubicweb-web-help-1.3.3-1.noarch.rpm
checksum_type: sha256
description:
  This cube provides a dynamic view selection system. This system allows
  semi-automatic XHTML/XML/JSON/text generation, based on context.
  All this was once available in CubicWeb 3 as a `cubicweb.web` module.
  This code is still maintained, however we no longer add new features.


pkgId: 2364dcb4fefa09565765cb810de086acaffae8d71df4f53e43eec699f1007587
name: python-cudaq-help
arch: noarch
version: 0.9.1
epoch: 0
release: 1
summary: Development documents and examples for cudaq
url: https://developer.nvidia.com/cuda-q
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cudaq-0.9.1-1.src.rpm
location_href: Packages/python-cudaq-help-0.9.1-1.noarch.rpm
checksum_type: sha256
description:
  CUDA-Q is a comprehensive framework for quantum programming. It features:

  - A programming model which extends C++ and Python with quantum kernels,
    enabling high-level programming in familiar languages
  - A high-performance quantum compiler, `nvq++`, based on the industry standard
    LLVM toolchain
  - Interoperability with all of the leading models and tools for accelerated
    computing, including CUDA, ISO standard parallelism, OpenMP, and OpenACC
  - The ability to utilize and seamlessly switch between different quantum
    technologies, including state-of-the-art simulator backends with NVIDIA
    cuQuantum and a number of different physical quantum processors (QPUs)

  The CUDA-Q Python wheels contain the Python API and core components of CUDA-Q.
  This package installs CUDA-Q binaries that are compatible with a CUDA version
  11.x (where x >= 8) or 12.x. More information about available packages as
  well as a link to the documentation and examples for each version can be found
  in the [release notes][cudaq_docs_releases]. System and compatibility
  requirements are listed in the Installation Guide of the linked documentation.

  **Note**: CUDA-Q is currently only supported on Linux operating systems using
  `x86_64` or `aarch64`/`arm64` processors.

  [cudaq_docs_releases]:
      https://nvidia.github.io/cuda-quantum/latest/releases.html



  [//]: # (Begin complete install)

  CUDA-Q does not require a GPU to use, but some components are GPU-accelerated.

  Getting started with CUDA-Q on `x86_64` platforms simply requires `pip install
  cudaq`. Please make sure your `pip` version is \>= 24.0.
  If you have an NVIDIA GPU on your host system, you will be
  able to use it without any further installation steps.

  > **Important:**
  > Please check if you have an existing installation of the `cuda-quantum`, `cudaq-quantum-cu11`, or `cuda-quantum-cu12` package, and uninstall it prior to installation. Different CUDA-Q binary distributions may conflict with each other causing issues.


  If you want to perform multi-GPU simulations, or if you are using
  `aarch64`/`arm64` processors, additional components must be installed. We
  recommend using [Conda](https://docs.conda.io/en/latest/) to do so. If you are
  not already using Conda, you can install a minimal version following the
  instructions [here](https://docs.anaconda.com/miniconda/). The following
  commands will create and activate a complete environment for CUDA-Q with all its
  dependencies:

  [//]: # (Begin conda install)

  ```console
  cuda_version=11.8.0 # set this variable to version 11.x (where x >= 8) or 12.x
  conda create -y -n cudaq-env python=3.11 pip
  conda install -y -n cudaq-env -c "nvidia/label/cuda-${cuda_version}" cuda
  conda install -y -n cudaq-env -c conda-forge mpi4py openmpi cxx-compiler
  conda env config vars set -n cudaq-env LD_LIBRARY_PATH="$CONDA_PREFIX/envs/cudaq-env/lib:$LD_LIBRARY_PATH"
  conda env config vars set -n cudaq-env MPI_PATH=$CONDA_PREFIX/envs/cudaq-env
  conda activate cudaq-env
  pip install cudaq
  source $CONDA_PREFIX/lib/python3.11/site-packages/distributed_interfaces/activate_custom_mpi.sh
  ```

  [//]: # (End conda install)

  You must configure MPI by setting the following environment variables:

  [//]: # (Begin ompi setup)

  ```console
  export OMPI_MCA_opal_cuda_support=true OMPI_MCA_btl='^openib'
  ```

  [//]: # (End ompi setup)

  *If you do not set these variables you may encounter a segmentation fault.*

  **Important**: It is *not* sufficient to set these variable within the Conda
  environment, like the commands above do for `LD_LIBRARY_PATH`. To avoid having
  to set them every time you launch a new shell, we recommend adding them to
  `~/.profile` (create the file if it does not exist), and to `~/.bash_profile` or
  `~/.bash_login` if such a file exists.

  [//]: # (End complete install)

  MPI uses [SSH](https://en.wikipedia.org/wiki/Secure_Shell) or
  [RSH](https://en.wikipedia.org/wiki/Remote_Shell) to communicate with each node
  unless another resource manager, such as
  [SLURM](https://slurm.schedmd.com/overview.html), is used. If you are
  encountering an error "The value of the MCA parameter `plm_rsh_agent` was set to
  a path that could not be found", please make sure you have an SSH Client
  installed.



  You should now be able to import CUDA-Q and start building quantum programs in
  Python!

  ```console
  import cudaq

  kernel = cudaq.make_kernel()
  qubit = kernel.qalloc()
  kernel.x(qubit)
  kernel.mz(qubit)

  result = cudaq.sample(kernel)
  ```

  Additional examples and documentation are linked in the [release
  notes][cudaq_docs_releases].



  There are many ways in which you can get involved with CUDA-Q. If you are
  interested in developing quantum applications with CUDA-Q, our [GitHub
  repository][github_link] is a great place to get started! For more information
  about contributing to the CUDA-Q platform, please take a look at
  [Contributing.md](https://github.com/NVIDIA/cuda-quantum/blob/main/Contributing.md).



  CUDA-Q is an open source project. The source code is available on
  [GitHub][github_link] and licensed under [Apache License
  2.0](https://github.com/NVIDIA/cuda-quantum/blob/main/LICENSE). CUDA-Q makes use
  of the NVIDIA cuQuantum SDK to enable high-performance simulation, which is held
  to its own respective license.

  [github_link]: https://github.com/NVIDIA/cuda-quantum/



  Please let us know your feedback and ideas for the CUDA-Q platform in the
  [Discussions][discussions] tab of our [GitHub repository][github_repo], or [file
  an issue][cuda_quantum_issues]. To report security concerns please reach out to
  [cuda-quantum@nvidia.com](mailto:cuda-quantum@nvidia.com).

  [discussions]: https://github.com/NVIDIA/cuda-quantum/discussions
  [cuda_quantum_issues]: https://github.com/NVIDIA/cuda-quantum/issues
  [github_repo]: https://github.com/NVIDIA/cuda-quantum

rpm_license:
  Apache License Version 2.0  Copyright (c) 2023 - 2024 NVIDIA Corporation & Affiliates All rights reserved.  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: 846552f46e8bf7dd91dfc4436337cf8e384cdc4e9af93ad389a74e873ac411f8
name: python-culsans-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for culsans
url: https://pypi.org/project/culsans/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-culsans-0.5.0-1.src.rpm
location_href: Packages/python-culsans-help-0.5.0-1.noarch.rpm
checksum_type: sha256
rpm_license:
  Copyright 2024 Ilya Egorov <0x42005e1f@gmail.com>.  Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.


pkgId: 91387fea04e84beb848cdf27d3ce26ea852698276ad7149d8e2e954a25512d39
name: python-cumulus-library-help
arch: noarch
version: 4.1.2
epoch: 0
release: 1
summary: Development documents and examples for cumulus-library
url: https://pypi.org/project/cumulus-library/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cumulus-library-4.1.2-1.src.rpm
location_href: Packages/python-cumulus-library-help-4.1.2-1.noarch.rpm
checksum_type: sha256
description:
  A framework for designing, executing, and distributing SQL queries packaged as "studies", e.g., for quality monitoring, clinical research, or public health. Part of the [SMART on FHIR Cumulus Project](https://smarthealthit.org/cumulus/)



  For end users, just run `pip install cumulus-library`.
  For running from source, checkout the repo, and at the project root run `pip install -e .`. If you're not working on new features, you should check out the tag associated with the latest release.

  For more information, [browse the documentation](https://docs.smarthealthit.org/cumulus/library).


pkgId: b6f70e8bea1f5f2088a1d1876d87aef1a46956c6a7ed32fa50f4f0e620bd7039
name: python-cumulusci-help
arch: noarch
version: 4.0.1
epoch: 0
release: 1
summary: Development documents and examples for cumulusci
url: https://github.com/SFDO-Tooling/CumulusCI
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cumulusci-4.0.1-1.src.rpm
location_href: Packages/python-cumulusci-help-4.0.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Code Coverage](https://coveralls.io/repos/github/SFDO-Tooling/CumulusCI/badge.svg?branch=main)](https://coveralls.io/github/SFDO-Tooling/CumulusCI?branch=main)
  [![PyPI](https://img.shields.io/pypi/v/cumulusci)](https://pypi.org/project/cumulusci/)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cumulusci)
  ![PyPI - License](https://img.shields.io/pypi/l/cumulusci)
  [![Documentation Status](https://readthedocs.org/projects/cumulusci/badge/?version=latest)](https://cumulusci.readthedocs.io/en/latest/?badge=latest)

  CumulusCI helps build great applications on the Salesforce platform by
  automating org setup, testing, and deployment for everyone --- from
  developers and admins to testers and product managers.

  **Best practices, proven at scale.** CumulusCI provides a complete
  development and release process created by Salesforce.org to build and
  release applications to thousands of users on the Salesforce platform.
  It\'s easy to start new projects with a standard set of tasks (single
  actions) and flows (sequences of tasks), or customize by adding your
  own.

  **Batteries included.** Out-of-the-box features help you quickly:

  -   Build sophisticated orgs with automatic installation of
      dependencies.
  -   Load and capture sample datasets to make your orgs feel real.
  -   Apply transformations to existing metadata to tailor orgs to your
      specific requirements.
  -   Run builds in continuous integration systems.
  -   Create end-to-end browser tests and setup automation using [Robot
      Framework](https://cumulusci.readthedocs.io/en/latest/robotframework.html).
  -   Generate synthetic data on any scale, from a single record to a
      million, using
      [Snowfakery](https://cumulusci.readthedocs.io/en/latest/cookbook.html#large-volume-data-synthesis-with-snowfakery).

  **Build anywhere.** Automation defined using CumulusCI is portable. It
  is stored in a source repository and can be run from your local command
  line, from a continuous integration system, or from a customer-facing
  MetaDeploy installer. CumulusCI can run automation on scratch orgs
  created using the Salesforce CLI, or on persistent orgs like sandboxes,
  production orgs, and Developer Edition orgs.



  For a tutorial introduction to CumulusCI, complete the [Build
  Applications with
  CumulusCI](https://trailhead.salesforce.com/en/content/learn/trails/build-applications-with-cumulusci)
  trail on Trailhead.

  To go in depth, read the [full
  documentation](https://cumulusci.readthedocs.io/en/latest/).

  If you just want a quick intro, watch [these screencast
  demos](https://cumulusci.readthedocs.io/en/latest/demos.html) of using
  CumulusCI to configure a Salesforce project from a GitHub repository.

  For a live demo with voiceover, please see Jason Lantz\'s [PyCon 2020
  presentation](https://www.youtube.com/watch?v=XL77lRTVF3g) from minute
  36 through minute 54.



  Ask in the [CumulusCI (CCI) group in the Trailblazer
  Community](https://success.salesforce.com/_ui/core/chatter/groups/GroupProfilePage?g=0F9300000009M9ZCAU).

  _Please note:_ CumulusCI is distributed under an [open source
  license](https://github.com/SFDO-Tooling/CumulusCI/blob/main/LICENSE)
  and is not covered by the Salesforce Master Subscription Agreement.

  <!-- Changelog -->




  -   Fixed a ModuleNotFoundError for docutils by adding the dependency `docutils` by [@jstvz](https://github.com/jstvz) in [#3558](https://github.com/SFDO-Tooling/CumulusCI/pull/3558).

  **Full Changelog**: https://github.com/SFDO-Tooling/CumulusCI/compare/v4.0.0...v4.0.1


pkgId: 0a022da0272fc10b7282a85dc3c48776c5e15ce9a32060f8334f12f3766ebea9
name: python-curia-help
arch: noarch
version: 4.21.1
epoch: 0
release: 1
summary: Development documents and examples for curia
url: https://pypi.org/project/curia/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-curia-4.21.1-1.src.rpm
location_href: Packages/python-curia-help-4.21.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/curia.svg)](https://badge.fury.io/py/curia)

  [![Python 3.8](https://img.shields.io/badge/python-3.8-blue.svg)](https://www.python.org/downloads/release/python-380/)
  [![Python 3.9](https://img.shields.io/badge/python-3.9-blue.svg)](https://www.python.org/downloads/release/python-390/)
  [![Python 3.10](https://img.shields.io/badge/python-3.10-blue.svg)](https://www.python.org/downloads/release/python-3100/)
  [![Python 3.11](https://img.shields.io/badge/python-3.11-blue.svg)](https://www.python.org/downloads/release/python-3110/)

  [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=Curia-ai_curia-python-sdk&metric=alert_status&token=e6d33fff8f3c9375c06d3b3deba711b1891c0b0b)](https://sonarcloud.io/dashboard?id=Curia-ai_curia-python-sdk)
  [![Bugs](https://sonarcloud.io/api/project_badges/measure?project=Curia-ai_curia-python-sdk&metric=bugs&token=e6d33fff8f3c9375c06d3b3deba711b1891c0b0b)](https://sonarcloud.io/dashboard?id=Curia-ai_curia-python-sdk)
  [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=Curia-ai_curia-python-sdk&metric=coverage&token=e6d33fff8f3c9375c06d3b3deba711b1891c0b0b)](https://sonarcloud.io/dashboard?id=Curia-ai_curia-python-sdk)
  [![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=Curia-ai_curia-python-sdk&metric=sqale_rating&token=e6d33fff8f3c9375c06d3b3deba711b1891c0b0b)](https://sonarcloud.io/dashboard?id=Curia-ai_curia-python-sdk)
  [![Reliability Rating](https://sonarcloud.io/api/project_badges/measure?project=Curia-ai_curia-python-sdk&metric=reliability_rating&token=e6d33fff8f3c9375c06d3b3deba711b1891c0b0b)](https://sonarcloud.io/dashboard?id=Curia-ai_curia-python-sdk)
  [![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=Curia-ai_curia-python-sdk&metric=security_rating&token=e6d33fff8f3c9375c06d3b3deba711b1891c0b0b)](https://sonarcloud.io/dashboard?id=Curia-ai_curia-python-sdk)
  [![Vulnerabilities](https://sonarcloud.io/api/project_badges/measure?project=Curia-ai_curia-python-sdk&metric=vulnerabilities&token=e6d33fff8f3c9375c06d3b3deba711b1891c0b0b)](https://sonarcloud.io/dashboard?id=Curia-ai_curia-python-sdk)

  ![Release](https://github.com/Curia-ai/curia-python-sdk/workflows/Release%20Workflow/badge.svg)


  Curia Python SDK is a Python library for interacting with the Curia Platform.

  For detailed documentation, including the API reference, see our docs at https://Curia-ai.github.io/curia-python-sdk/.


  The Curia Python SDK is built to public PyPi and can be installed with `pip` as follows:
  ```
  pip install curia
  ```

  You can install from source by cloning this repository and utilizing poetry:
  ```
  git clone https://github.com/Curia-ai/curia-python-sdk.git
  cd curia-python-sdk
  poetry install
  ```


  Curia Python SDK supports Unix/Linux and Mac.


  Curia Python SDK is tested on:
  - Python 3.8
  - Python 3.9
  - Python 3.10
  - Python 3.11


  The Curia Python SDK requires a Curia API Token to access the Curia API. To access your API Token visit the instance
  of the curia platform you are utilizing and access the developer settings, e.g. in prod:
  ```
  https://aledade.dev.curia.ai/settings/developer
  ```



  While the Curia Python SDK supports Python 3.8+, we develop using Python 3.9. One of the easiest ways to install Python 3.9 is with [pyenv](https://github.com/pyenv/pyenv)
  ```
  pyenv install 3.9.7
  pyenv local 3.9.7
  ```

  Curia Python SDK uses [Poetry](https://python-poetry.org/) for dependency management. We suggest installing poetry
  through pipx. You can install pipx with Homebrew:
  ```brew install pipx```

  Once pipx is installed, you can install poetry:
  ```pipx install poetry```

  Once poetry is installed, you can install the dependencies for the Curia Python SDK.

  To install dependencies, run:
  ```
  poetry install
  ```

  To install dependencies for development, run:
  ```
  poetry install --with=dev
  ```


  We utilize [Poe](https://poethepoet.natn.io/index.html), a poetry plugin, to handle common tasks. To see a list of commands, run:
  ```
  poetry run poe --help
  ```



  To run tests, run:
  ```
  poetry run poe test
  ```


  To run linting, run:
  ```
  poetry run poe lint
  ```


  To build the SDK, run:
  ```
  poetry run poe build
  ```


  To clean build artifacts and test artifacts, run:
  ```
  poetry run poe clean
  ```


  Curia Python SDK has Sphinx docs.
  To build the docs, run:
  ```
  poetry run poe build-docs
  ```

  To preview the site with a Python web server:
  ```
  cd docs/_build/html
  python -m http.server 8000
  ```
  View the docs by visiting http://localhost:8080



  Portions of the Curia Python SDK are generated using the Swagger Codegen. To manually regenerate the SDK, you will need
  to install gnu-sed. Visit https://medium.com/@bramblexu/install-gnu-sed-on-mac-os-and-set-it-as-default-7c17ef1b8f64 to see how to install gnu-sed for consistency in fixing swagger imports
  ```export PATH="/usr/local/opt/gnu-sed/libexec/gnubin:$PATH"```

  Once you have gnu-sed installed, you can run the following command to regenerate the SDK:
  ```
  poetry run poe swagger-codegen-prod
  ```
  to regenerate the SDK from the production environment, or
  ```
  poetry run poe swagger-codegen-dev
  ```
  to regenerate the SDK from the development environment.



  Sometimes we may have updates that are currently in the development environment,
  but not accessible in production yet.  When this happens, the SDK will not reflect
  the latest changes in develop.  To be able to use new features of the API, you can
  cut a new release of the SDK and use the latest version.

  *BE CAREFUL - MAKE SURE YOU KNOW WHY YOU ARE DOING THIS*

  To cut a new release based on the Dev API, run `poetry run poe swagger-codegen-dev`.  In order
  to get some sed commands to work on Mac, you will need to install and use
  [Gnu-Sed](#use-gnu-sed)

  First, update the version in `src/curia/__init__.py`
  Then build the source distribution: `poetry run poe build`
  Make sure you have twine installed: `pip install twine`.
  Finally, upload the new distribution to pypi: `python -m twine upload dist/*`
  You will be prompted for a username and password.
  - Your username is `__token__`
  - Your password is stored in 1Password in the Curia vault in the `PyPi Curia Project` secure document


pkgId: 32de7c1b91fb2fd32ac87e12d32fcdb5914a4ac3a2f87bc904c7bd2cc5d06dd8
name: python-curiosity
arch: noarch
version: 54593
epoch: 0
release: 1
summary: The official Python driver for the Curiosity Search engine (https://curiosity.ai/).
url: http://curiosity.ai
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-curiosity-54593-1.src.rpm
location_href: Packages/python-curiosity-54593-1.noarch.rpm
checksum_type: sha256
description:
  The official Python driver for Curiosity (https://curiosity.ai/).

  The Python driver makes it easy to:
  * upload files to your workspace
  * add nodes and relationships to the graph
  * create users, teams and manage access
  * run queries against the graph



  Run `pip install curiosity` to install the Python driver from [PyPI](https://pypi.org/project/curiosity/).


  Replace the `server`,  and `connector_name` in the code sample below.
  * `server` : The full url to your Curiosity system. The used port is printed in the beginning of the log output of the Curiosity instance. The url has to end with `/api`.
  * `lib_token` : You have to create a library token  first, in order to use this library with your Curiosity instance. See the [documentation](https://dev.curiosity.ai/data-sources/api-integrations/api-tokens) on how to create an API token.
  * `connector_name` : A descriptive name for your Connector.

  You can use the methods on the `graph` object to interact with your Curiosity Workspace. Check out the [API documentation](https://dev.curiosity.ai/data-sources/api-integrations) to see examples on how to write a data connector.

  ```python
  from curiosity import Graph

  def main():
      
      server = "http://localhost:8080/api"

      
      lib_token = "eqJHbGci..."

      
      connector_name = "Python data connector"

      with Graph.connect(server, lib_token, connector_name) as graph:

          
          
          fullpath = "./sample.pdf"
          filename = "sample.pdf"
          source = "Samples"

          graph.upload_file_by_path(fullpath, filename, source)

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


pkgId: 991c050058e8940b865c9b111e0c7ed584e2892528be002d907a5a98f71bd25e
name: python-curvature-filtrations-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for curvature-filtrations
url: https://pypi.org/project/curvature-filtrations/
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-curvature-filtrations-0.1.1-1.src.rpm
location_href: Packages/python-curvature-filtrations-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  <img src="docs/source/_static/scott_logo.png" alt="SCOTT logo"  style="float: right; width: 150px; height: 150px; margin-left: 10px;">





  [![Maintainability](https://api.codeclimate.com/v1/badges/875f73368ad03e6cd94e/maintainability)](https://codeclimate.com/github/aidos-lab/curvature-filtrations/maintainability) ![GitHub contributors](https://img.shields.io/github/contributors/aidos-lab/CFGGME) ![GitHub](https://img.shields.io/github/license/aidos-lab/CFGGME) [![arXiv](https://img.shields.io/badge/arXiv-2301.12906-b31b1b.svg)](https://arxiv.org/abs/2301.12906)

  `SCOTT` is a Python package for computing **curvature filtrations** for graphs and graph distributions. This repository accompanies our NeurIPS 2023 paper: [_Curvature Filtrations for Graph Generative Model Evaluation_](https://arxiv.org/abs/2301.12906).

  Our method introduces a novel way to compare graph distributions, avoiding the limitations of Maximal Mean Discrepancy (MMD), which has known [drawbacks](https://arxiv.org/abs/2106.01098).

  By combining **discrete curvature** on graphs with **persistent homology**, `SCOTT` provides expressive descriptors of graph sets that are:

  - **Robust**
  - **Stable**
  - **Expressive**
  - **Compatible with Statistical Testing**

  The package is highly adaptable, offering several options for **user customization**, including different curvature computation methods and diverse metrics for comparing persistent homology outputs.



  If you find this package useful in your research, please consider citing:

  ```bibtex
  @misc{southern2023curvature,
        title={Curvature Filtrations for Graph Generative Model Evaluation},
        author={Joshua Southern and Jeremy Wayland and Michael Bronstein and Bastian Rieck},
        year={2023},
        eprint={2301.12906},
        archivePrefix={arXiv},
        primaryClass={cs.LG}
  }
  ```





  Install `curvature-filtrations` via pip:

  ```bash
  $ pip install curvature-filtrations
  ```



  Our dependencies are managed with [`poetry`](https://python-poetry.org), which can be installed with `pip install poetry`. To install from source:

  1. Clone the repository

  ```bash
  $ git clone https://github.com/aidos-lab/curvature-filtrations.git
  ```

  1. Navigate to the directory

  ```bash
  $ cd curvature-filtrations
  ```

  3. Install dependencies

  ```bash
  $ poetry install
  ```



  The example.py script demonstrates how to compute the distance between two graph distributions.

  To use SCOTT with your own data, replace the example graph distributions with your own. Distributions should be lists of `networkx` graphs or single `networkx` graphs.



  ```bash
  python scripts/example.py
  ```



  For a walkthrough of customization options and the intermediary functionalities supported by SCOTT objects, please see `/notebooks`. We offer the following two tutorials:



  **_Read this section if:_** Your primary goal is to find the distance between your graph distributions, but you are looking for additional ways to customize the curvature and distance measures used.

  Functionalities demonstrated in this tutorial include:

  - Changing the method used for curvature calculations and associated hyperparameters
  - Selecting and customizing the vectorization used to compare persistence diagrams



  **_Read this section if:_** You want to better understand the underlying workflow of this process and/or are interested in the output from intermediate steps in the process.

  Functionalities demonstrated in this tutorial include:

  - Calculating curvature for one graph or graph distribution
  - Executing a curvature filtration to produce a persistence diagram
  - Converting persistence diagrams into a topological descriptor (e.g. persistence landscape)
  - Computing the distance between topological descriptors

  Both tutorials are supported by `/notebooks/utils.py`.





  `KILT` stands for: *K*rvature-*I*nformed *L*inks and *T*opology is an object that can compute curvature filtrations for single graphs.

  ```python
  import networkx as nx
  from scott import KILT,Comparator

  G = nx.erdos_reyni(14,0.4)

  kilt = KILT(measure="forman_curvature")

  D = kilt.fit_transform(G)
  print(f"Forman Curvature Filtration:")
  print(f"Curvature Filtration Values:{kilt.curvature}")
  print(D)
  ```



  `Comparator` handles comparisons between graphs or graph distributions!

  ```python
  import networkx as nx
  from scott import KILT,Comparator

  graph_dist1 = [nx.erdos_reyni(10,0.4) for _ in range(40)]
  graph_dist2 = [nx.erdos_reyni(20,0.6) for _ in range(50)]

  compare = Compare(measure="forman_curvature")

  dist = compare.fit_transform(graph_dist1,graph_dist2,metric="image")

  print(f"Distance between distributions measured by Forman Filtration: {dist}")
  ```


pkgId: db179f7a1f627a4d1bd23ad1cd59754aa0ad536b9fce9ebcf6685874e222ade6
name: python-customgpt-cli-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for customgpt-cli
url: https://customgpt.ai
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-customgpt-cli-0.1.3-1.src.rpm
location_href: Packages/python-customgpt-cli-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/customgpt-cli.svg)](https://badge.fury.io/py/customgpt-cli)
  [![Python Support](https://img.shields.io/pypi/pyversions/customgpt-cli.svg)](https://pypi.org/project/customgpt-cli/)
  [![Documentation Status](https://readthedocs.org/projects/customgpt-cli/badge/?version=latest)](https://customgpt-cli.readthedocs.io/en/latest/?badge=latest)
  [![Coverage Status](https://codecov.io/gh/yourusername/customgpt-cli/branch/main/graph/badge.svg)](https://codecov.io/gh/yourusername/customgpt-cli)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![Docker Pulls](https://img.shields.io/docker/pulls/yourusername/customgpt-cli.svg)](https://hub.docker.com/r/yourusername/customgpt-cli)

  🚀 A powerful command-line interface for CustomGPT SDK, enabling efficient project management and automation.



  - 🛠️ Full CustomGPT SDK integration
  - 🔐 Secure API key management
  - 📊 Project management and monitoring
  - 🤖 Conversation handling
  - 📄 Page management
  - 🐳 Docker support
  - 🔄 Bulk operations
  - 📊 Advanced filtering



  ```bash
  pip install customgpt-cli
  ```



  The CLI requires your CustomGPT API key. You can provide it in two ways:

  1. Environment Variable (recommended):
  ```bash
  export CUSTOMGPT_API_KEY=your_api_key
  customgpt-cli list-projects
  ```

  2. Command Line Argument:
  ```bash
  customgpt-cli --api-key YOUR_API_KEY list-projects
  ```

  Note: Command line argument takes precedence over environment variable if both are set.





  Create a project:
  ```bash

  export CUSTOMGPT_API_KEY=your_api_key


  customgpt-cli create-project --name "My Test Project With Sitemap" --sitemap "https://adorosario.github.io/small-sitemap.xml" --format id-only


  customgpt-cli create-project --name "My Test Project With File" --file /path/to/file.pdf --format json
  ```

  List projects with filtering:
  ```bash

  customgpt-cli list-projects


  customgpt-cli list-projects --name-filter "test.*project"


  customgpt-cli list-projects --inactive-days 30


  customgpt-cli list-projects --min-queries 100 --max-queries 1000


  customgpt-cli list-projects --format json
  customgpt-cli list-projects --format table
  customgpt-cli list-projects --format id-only
  ```

  Show a project details:
  ```bash
  customgpt-cli show-project --project-id PROJECT_ID --format json
  ```

  Update a project:
  ```bash
  customgpt-cli update-project --project-id PROJECT_ID --name "New Name" --is-shared 1 --format json
  ```

  Delete projects:
  ```bash

  customgpt-cli delete-projects --project-ids PROJECT_ID


  customgpt-cli delete-projects --project-ids "id1,id2,id3"


  customgpt-cli delete-projects --project-ids PROJECT_ID --dry-run


  customgpt-cli delete-projects --project-ids PROJECT_ID --force
  ```



  Create a conversation:
  ```bash
  customgpt-cli create-conversation --project-id PROJECT_ID --name "My Conversation"
  ```

  Send a message:
  ```bash

  customgpt-cli send-message --project-id PROJECT_ID --session-id SESSION_ID --prompt "Hello"


  customgpt-cli send-message --project-id PROJECT_ID --session-id SESSION_ID --prompt "Hello" --stream


  customgpt-cli send-message --project-id PROJECT_ID --session-id SESSION_ID --prompt "Hello" --persona "You are a helpful assistant"
  ```



  Get project pages:
  ```bash
  customgpt-cli get-pages --project-id PROJECT_ID
  ```

  Delete a page:
  ```bash
  customgpt-cli delete-page --project-id PROJECT_ID --page-id PAGE_ID
  ```

  Reindex a page:
  ```bash
  customgpt-cli reindex-page --project-id PROJECT_ID --page-id PAGE_ID
  ```



  Get project settings:
  ```bash
  customgpt-cli get-project-settings --project-id PROJECT_ID
  ```

  Update project settings:
  ```bash
  customgpt-cli update-project-settings --project-id $PROJECT_ID --default-prompt "Test prompt" --chatbot-avatar "./tests/files/test.png" --chatbot-background "./tests/files/test.png" --example-questions '["Test questions"]' --response-source "default" --chatbot-msg-lang "en" --chatbot-color "#0e57cc" --chatbot-toolbar-color "#0e57cc" --persona-instructions "Test instructions" --citations-answer-source-label-msg "Test label" --citations-sources-label-msg "Test label" --hang-in-there-msg "Test message" --chatbot-siesta-msg "Test message" --is-loading-indicator-enabled --enable-citations 0 --enable-feedbacks --citations-view-type "user" --no-answer-message "Test message" --ending-message "Test message" --remove-branding --enable-recaptcha-for-public-chatbots --chatbot-model "gpt-4-o" --is-selling-enabled --license-slug "test" --selling-url "test"
  ```



  Get plugins:
  ```bash
  customgpt-cli get-plugins --project-id PROJECT_ID
  ```

  Create plugins:
  ```bash
  customgpt-cli create-plugin --project-id $PROJECT_ID --model-name "TestPlugin" --human-name "Test Assistant" --keywords "test,automation" --description "This is a helpful automation tool." --is-active
  ```

  Update plugins:
  ```bash
  customgpt-cli update-plugin --project-id $PROJECT_ID --model-name "Updated" --human-name "Updated Assistant" --keywords "updated,assistant" --description "Trusted information about indoor plants and gardening." --is-active
  ```



  Get page metadata:
  ```bash
  customgpt-cli get-page-metadata --project-id PROJECT_ID --page-id PAGE_ID
  ```

  Update page metadata:
  ```bash
  customgpt-cli update-page-metadata --project-id PROJECT_ID --page-id PAGE_ID --title "Page Title" --url "https://page-url.com" --description "Page description" --image "https://image-url.com/image.png"
  ```



  Get reports:
  ```bash

  customgpt-cli get-traffic-report --project-id PROJECT_ID --filters '["traffic", "pages"]'


  customgpt-cli get-queries-report --project-id PROJECT_ID --filters '["queries", "pages"]'


  customgpt-cli get-conversations-report --project-id PROJECT_ID --filters '["conversations", "pages"]'


  customgpt-cli get-analysis-report --project-id PROJECT_ID --filters '["analysis", "pages"]'
  ```



  Get limits:
  ```bash
  customgpt-cli get-limits
  ```



  Get citations:
  ```bash
  customgpt-cli get-citations --project-id PROJECT_ID --citation-id CITATION_ID
  ```



  Get sources:
  ```bash
  customgpt-cli list-sources --project-id PROJECT_ID
  ```

  Create a source:
  ```bash

  customgpt-cli create-source --project-id PROJECT_ID --sitemap-path URL --file-data-retension --is-ocr-enabled --is-anonymized


  customgpt-cli create-source --project-id PROJECT_ID --file PATH --file-data-retension --is-ocr-enabled --is-anonymized
  ```

  Update source:
  ```bash
  customgpt-cli update-source --project-id PROJECT_ID --source-id SOURCE_ID --executive-js --data-refresh-frequency never --create-new-pages --remove-unexist-pages --refresh-existing-pages always --refresh-schedule ["00:00","08:00"]
  ```

  Delete source:
  ```bash
  customgpt-cli delete-source --project-id PROJECT_ID --source-id SOURCE_ID
  ```

  Sync source:
  ```bash
  customgpt-cli sync-source --project-id PROJECT_ID --source-id SOURCE_ID
  ```



  Get user:
  ```bash
  customgpt-cli get-user
  ```



  Here is an examples of how to use the CLI in scripts:

  1. Export project IDs to a file and process them:
  ```bash

  export CUSTOMGPT_API_KEY=your_api_key


  customgpt-cli list-projects --name-filter "test" --format id-only > projects.txt


  customgpt-cli delete-projects --project-ids $(paste -s -d, projects.txt) --force
  ```



  The CLI supports multiple output formats for better integration with other tools:

  - `table`: Human-readable formatted table (default)
  - `json`: JSON format for parsing
  - `csv`: CSV format for stats data
  - `id-only`: Just the IDs, one per line (good for scripting)



  The CLI includes several safety features:

  - `--dry-run`: Shows what would be deleted without actually deleting
  - Confirmation prompts for destructive operations
  - `--force` flag to skip confirmations in scripts
  - Error handling with informative messages



  Contributions are welcome! Please feel free to submit a Pull Request.



  MIT License


pkgId: e24141331236a37379bb0a3ecdad530a3cc2328d50eab3e426489637b08254a0
name: python-cut-detector-help
arch: noarch
version: 1.6.2
epoch: 0
release: 1
summary: Development documents and examples for cut-detector
url: https://github.com/15bonte/cut-detector
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cut-detector-1.6.2-1.src.rpm
location_href: Packages/python-cut-detector-help-1.6.2-1.noarch.rpm
checksum_type: sha256
description:
  This [napari] plugin was generated with [Cookiecutter] using [@napari]'s [cookiecutter-napari-plugin] template.
  <!--
  Don't miss the full getting started guide to set up your new package:
  https://github.com/napari/cookiecutter-napari-plugin#getting-started
  and review the napari docs for plugin developers:
  https://napari.org/stable/plugins/index.html
  -->
  <video width="640" height="480" controls>
    <source src="https://github.com/15bonte/cut-detector-models/blob/main/demo.mp4" type="video/mp4">
    Your browser does not support the video tag.
  </video>


  It is highly recommended to create a dedicated conda environment, by following these few steps:
  1. Install an [Anaconda] distribution of Python. Note you might need to use an anaconda prompt if you did not add anaconda to the path.
  2. Open an Anaconda prompt as admin to create a new environment using [conda]. We advice to use python 3.10 and conda 23.10.0, to get conda-libmamba-solver as default solver.
  ```bash
  conda create --name cut_detector python=3.10 conda=23.10.0
  conda activate cut_detector
  ```

  Once in a dedicated environment, our package can be installed via [pip]:
  ```bash
  pip install cut_detector
  ```
  Alternatively, you can clone the github repo to access to playground scripts.
  ```bash
  git clone https://github.com/15bonte/cut-detector.git
  cd cut-detector
  pip install -e .
  ```

  We highly recommend to use GPU to speed up segmentation. To use your NVIDIA GPU, the first step is to download the dedicated driver from [NVIDIA].
  Next we need to remove the CPU version of torch:
  ```bash
  pip uninstall torch
  ```
  The GPU version of torch to be installed can be found [here](https://pytorch.org/get-started/locally/). You may choose the CUDA version supported by your GPU, and install it with conda. This package has been developed with the version 11.6, installed with this command:
  ```bash
  conda install pytorch==1.12.1 torchvision pytorch-cuda=11.6 -c pytorch -c nvidia
  ```

  To update cut-detector to the latest version, open an Anaconda prompt and use the following commands:
  ```bash
  conda activate cut_detector
  pip install cut-detector --upgrade
  ```

  Each detected cell division is labeled with one of the following categories:
  - NORMAL: Division happening as expected, where (at least) 1 micro-tubule cut is detected.
  - NO_MID_BODY_DETECTED: Along the cell division, no mid-body was detected on the MKLP1 channel. This category encompasses different cases: the detection may have failed, the mid-body may not express the fluorescence, or this may not actually be a division.
  - MORE_THAN_TWO_DAUGHTER_TRACKS: Tripolar division. This category encompasses both actual tripolar divisions and wrong identifications of daughter cells (mainly caused by segmentation issues).
  - NEAR_BORDER: Division close to the border of the image, hence ignored as it is likely to be difficult to detect micro-tubule cuts. A division is classified as NEAR_BORDER as soon as the distance between 1 detected mid-body and the border of the image is less than 20px.
  - NO_CUT_DETECTED: Division whose mid-body was detected, but with all micro-tubule bridges classified as "No cut". Likely to be at the end of the video, cells dying before the end of division, or cells going out of frame.
  - TOO_SHORT_CUT: First micro-tubule cut detected before or at 50 minutes. Ignored as this is very unlikely, so it is probably caused by a wrong division detection.

  Contributions are very welcome. Tests can be run with [tox], please ensure
  the coverage at least stays the same before you submit a pull request.

  Distributed under the terms of the [BSD-3] license,
  "cut-detector" is free and open source software

  If you encounter any problems, please [file an issue] along with a detailed description.
  [napari]: https://github.com/napari/napari
  [Cookiecutter]: https://github.com/audreyr/cookiecutter
  [@napari]: https://github.com/napari
  [MIT]: http://opensource.org/licenses/MIT
  [BSD-3]: http://opensource.org/licenses/BSD-3-Clause
  [GNU GPL v3.0]: http://www.gnu.org/licenses/gpl-3.0.txt
  [GNU LGPL v3.0]: http://www.gnu.org/licenses/lgpl-3.0.txt
  [Apache Software License 2.0]: http://www.apache.org/licenses/LICENSE-2.0
  [Mozilla Public License 2.0]: https://www.mozilla.org/media/MPL/2.0/index.txt
  [cookiecutter-napari-plugin]: https://github.com/napari/cookiecutter-napari-plugin
  [file an issue]: https://github.com/15bonte/cut-detector/issues
  [napari]: https://github.com/napari/napari
  [tox]: https://tox.readthedocs.io/en/latest/
  [pip]: https://pypi.org/project/pip/
  [PyPI]: https://pypi.org/
  [Anaconda]: https://www.anaconda.com/products/distribution
  [Fiji]: https://imagej.net/software/fiji/
  [NVIDIA]: https://www.nvidia.com/Download/index.aspx?lang=en-us
  [conda]: https://docs.conda.io/en/latest/


pkgId: f5bd55fdc42f0bab757eb8646f3f985da05342d98a33b5180df31bd76fa84757
name: python-cvpl-tools-help
arch: noarch
version: 0.8.2
epoch: 0
release: 1
summary: Development documents and examples for cvpl-tools
url: https://github.com/khanlab/cvpl_tools
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cvpl-tools-0.8.2-1.src.rpm
location_href: Packages/python-cvpl-tools-help-0.8.2-1.noarch.rpm
checksum_type: sha256
description:
  [`cvpl_tools` documentation](https://www.khanlab.ca/cvpl_tools/index.html)

  cvpl_tools is a Python package for utilities and classes related to the file I/O, dataset record keeping for image processing and computer vision.

  Functionalities this repository provides for managing datasets using DatasetReference:
  - DatasetReference keeps an ordered array of image file paths
  - Images are assigned unique IDs used to match with their annotation files
  - DatasetReference can be written to disk as json using strenc.py, recording down the image files used in a processing step and their file paths
  - cvpl_tools/fs.py provides interface to turn image files to and write them from numpy arrays
  - reader_from_cmd.py defines a utility function for creating DatasetReference by pattern matching image files to be included in the dataset
  - cvpl_tools/im folder provides an extensible segmentation pipeline that supports Napari visualization and intermediate result caching/checkpointing functionalities


  This repository uses [Poetry](https://python-poetry.org/docs/) to manage dependency.


pkgId: 690033fe04e61674a99aa1331d40bce5c610256a6e34a2a50601fabf1838945e
name: python-cvpysdk-help
arch: noarch
version: 11.38
epoch: 0
release: 1
summary: Development documents and examples for cvpysdk
url: https://pypi.org/project/cvpysdk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cvpysdk-11.38-1.src.rpm
location_href: Packages/python-cvpysdk-help-11.38-1.noarch.rpm
checksum_type: sha256
description:
  CVPySDK is a Python Package for Commvault Software.
  CVPySDK uses REST APIs to perform CommCell operations.


pkgId: 2d9d681701d3b81c121aa634443f908eb20ea914ddfbf827700d36a3f3d77d6e
name: python-cvxFin-help
arch: noarch
version: 0.3.1
epoch: 0
release: 1
summary: Development documents and examples for cvxFin
url: https://pypi.org/project/cvxFin/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cvxFin-0.3.1-1.src.rpm
location_href: Packages/python-cvxFin-help-0.3.1-1.noarch.rpm
checksum_type: sha256
description:
  ![Apache 2.0 License](https://img.shields.io/badge/License-APACHEv2-brightgreen.svg)

  I have decided to continue this project with cvxpy rather than cvxopt. test



  You need to install [task](https://taskfile.dev).
  Starting with

  ```bash
  task cvxFin:install
  ```

  will install [uv](https://github.com/astral-sh/uv) and create
  the virtual environment defined in
  pyproject.toml and locked in uv.lock.



  We install [marimo](https://marimo.io) on the fly within the aforementioned
  virtual environment. Executing

  ```bash
  task cvxFin:marimo
  ```

  will install and start marimo.

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


pkgId: a2290647d95c9da34fd8772b485b28bd2fda4ce07ef16023a20f5d56d7d5c82d
name: python-cvxbson-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for cvxbson
url: https://pypi.org/project/cvxbson/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cvxbson-0.1.0-1.src.rpm
location_href: Packages/python-cvxbson-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/cvxbson.svg)](https://badge.fury.io/py/cvxbson)
  [![Apache 2.0
  License](https://img.shields.io/badge/License-APACHEv2-brightgreen.svg)](https://github.com/cvxgrp/cvxbson/blob/master/LICENSE)
  [![Downloads](https://static.pepy.tech/personalized-badge/cvxbson?period=month&units=international_system&left_color=black&right_color=orange&left_text=PyPI%20downloads%20per%20month)](https://pepy.tech/project/cvxbson)
  [![Coverage Status](https://coveralls.io/repos/github/cvxgrp/cvxbson/badge.png?branch=main)](https://coveralls.io/github/cvxgrp/cvxbson?branch=main)

  [![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/cvxgrp/cvxbson)



  IPC stands for InterProcess Communication. It is a mechanism that allows to share
  data between processes. A traditional way to do so is to use json files.
  Json files are rather flexible and can be used to share data between different
  programming languages. However, they are not very efficient.

  Here we use their binary counterpart, bson files. Bson files are much more efficient
  but somewhat lack the flexibility of json files. Here we rely on the [bson](https://pypi.org/project/bson/)
  package to read and write bson files. We are interested in parsing dictionaries
  of numpy arrays, pandas and  polars dataframes as fast as possible.

  There might be faster ways to achieve this goal and we are open to suggestions
  and pull requests.

  We recommend using json files to transfer configurations and small amounts of data.
  Bson files can then be used to transfer large matrices. A coexistence is possible
  and encouraged.



  ```python
  import numpy as np

  from cvx.bson import read_bson, write_bson

  data = {"A": np.random.rand(50,50), "B": np.random.rand(50)}

  write_bson("test.bson", data)
  recovered = read_bson("test.bson")

  assert np.allclose(data["A"], recovered["A"])
  assert np.allclose(data["B"], recovered["B"])
  ```

  We have also implemented the same functionality in for json files but would advise
  against using it. It is much slower and less efficient.

  You may want to avoid the explicit construction of files.
  It is possible to work directly with bson strings. We provide methods for that, too.



  You need to install [task](https://taskfile.dev).
  Starting with

  ```bash
  task cvxbson:install
  ```

  will install [uv](https://github.com/astral-sh/uv) and create
  the virtual environment defined in
  pyproject.toml and locked in uv.lock.



  We install [marimo](https://marimo.io) on the fly within the aforementioned
  virtual environment. Executing

  ```bash
  task cvxbson:marimo
  ```

  will install and start marimo.


pkgId: f54d15cccecc87e4c37b2fa57586c71f621cfc6640a317766f970ebfb5284c95
name: python-cvxrisk-help
arch: noarch
version: 1.3.2
epoch: 0
release: 1
summary: Development documents and examples for cvxrisk
url: https://pypi.org/project/cvxrisk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cvxrisk-1.3.2-1.src.rpm
location_href: Packages/python-cvxrisk-help-1.3.2-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/cvxrisk.svg)](https://badge.fury.io/py/cvxrisk)
  [![Apache 2.0 License](https://img.shields.io/badge/License-APACHEv2-brightgreen.svg)](https://github.com/cvxgrp/simulator/blob/master/LICENSE)
  [![Downloads](https://static.pepy.tech/personalized-badge/cvxrisk?period=month&units=international_system&left_color=black&right_color=orange&left_text=PyPI%20downloads%20per%20month)](https://pepy.tech/project/cvxrisk)

  We provide an abstract `Model` class.
  The class is designed to be used in conjunction with [cvxpy](https://github.com/cvxpy/cvxpy).
  Using this class, we can formulate a function computing a standard minimum
  risk portfolio as

  ```python
  import cvxpy as cp

  from cvx.risk import Model


  def minimum_risk(w: cp.Variable, risk_model: Model, **kwargs) -> cp.Problem:
      """Constructs a minimum variance portfolio.

      Args:
          w: cp.Variable representing the portfolio weights.
          risk_model: A risk model.

      Returns:
          A convex optimization problem.
      """
      return cp.Problem(
          cp.Minimize(risk_model.estimate(w, **kwargs)),
          [cp.sum(w) == 1, w >= 0] + risk_model.constraints(w, **kwargs)
      )
  ```

  The risk model is injected into the function.
  The function is not aware of the precise risk model used.
  All risk models are required to implement the `estimate` method.

  Note that factor risk models work with weights for the assets but also with
  weights for the factors.
  To stay flexible we are applying the `**kwargs` pattern to the function above.



  A first example is a risk model based on the sample covariance matrix.
  We construct the risk model as follows

  ```python
  import numpy as np
  import cvxpy as cp

  from cvx.risk.sample import SampleCovariance

  riskmodel = SampleCovariance(num=2)
  w = cp.Variable(2)
  problem = minimum_risk(w, riskmodel)

  riskmodel.update(cov=np.array([[1.0, 0.5], [0.5, 2.0]]))
  problem.solve()
  print(w.value)
  ```

  The risk model and the actual optimization problem are decoupled.
  This is good practice and keeps the code clean and maintainable.

  In a backtest we don't have to reconstruct the problem in every iteration.
  We can simply update the risk model with the new data and solve the problem
  again. The implementation of the risk models is flexible enough to deal with
  changing dimensions of the underlying weight space.





  We offer a `SampleCovariance` class as seen above.



  Factor risk models use the projection of the weight vector into a lower
  dimensional subspace, e.g. each asset is the linear combination of $k$ factors.

  ```math
  r_i = \sum_{j=1}^k f_j \beta_{ji} + \epsilon_i
  ```

  The factor time series are $f_1, \ldots, f_k$. The loadings are the coefficients
  $\beta_{ji}$.
  The residual returns $\epsilon_i$ are assumed to be uncorrelated with the f
  actors.

  Any position $w$ in weight space projects to a position $y = \beta^T w$ in
  factor space. The variance for a position $w$ is the sum of the variance of the
  systematic returns explained by the factors and the variance of the
  idiosyncratic returns.

  ```math
  Var(r) = Var(\beta^T w) + Var(\epsilon w)
  ```

  We assume the residual returns are uncorrelated and hence

  ```math
  Var(r) = y^T \Sigma_f y + \sum_i w_i^2 Var(\epsilon_i)
  ```

  where $\Sigma_f$ is the covariance matrix of the factors and $Var(\epsilon_i)$
  is the variance of the idiosyncratic returns.

  Factor risk models are widely used in practice. Usually two scenarios are
  distinguished. A first route is to rely on estimates for the factor covariance
  matrix $\Sigma_f$, the loadings $\beta$ and the volatilities of the
  idiosyncratic returns $\epsilon_i$. Usually those quantities are provided by
  external parties, e.g. Barra or Axioma.

  An alternative would be to start with the estimation of factor time series
  $f_1, \ldots, f_k$.
  Usually they are estimated via a principal component analysis (PCA) of the
  asset returns.  It is then a simple linear regression to compute the loadings
  $\beta$. The volatilities of the idiosyncratic returns $\epsilon_i$ are computed
  as the standard deviation of the observed residuals.
  The factor covariance matrix $\Sigma_f$ may even be diagonal in this case as the
  factors are orthogonal.

  We expose a method to compute the first $k$ principal components.



  We currently also support the conditional value at risk (CVaR) as a risk
  measure.



  Starting with

  ```bash
  make install
  ```

  will install [uv](https://github.com/astral-sh/uv) and create
  the virtual environment defined in
  pyproject.toml and locked in uv.lock.



  We install [marimo](https://marimo.io) on the fly within the aforementioned
  virtual environment. Executing

  ```bash
  make marimo
  ```

  will install and start marimo.


pkgId: 3cba099db0395dddbc5a832dda4ea55ec12becaac92994e35a28bb2d1565a32e
name: python-cvxsimulator-help
arch: noarch
version: 1.3.1
epoch: 0
release: 1
summary: Development documents and examples for cvxsimulator
url: https://pypi.org/project/cvxsimulator/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cvxsimulator-1.3.1-1.src.rpm
location_href: Packages/python-cvxsimulator-help-1.3.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/cvxsimulator.svg)](https://badge.fury.io/py/cvxsimulator)
  [![Apache 2.0 License](https://img.shields.io/badge/License-APACHEv2-brightgreen.svg)](https://github.com/cvxgrp/simulator/blob/master/LICENSE)
  [![Downloads](https://static.pepy.tech/personalized-badge/cvxsimulator?period=month&units=international_system&left_color=black&right_color=orange&left_text=PyPI%20downloads%20per%20month)](https://pepy.tech/project/cvxsimulator)
  [![Coverage Status](https://coveralls.io/repos/github/cvxgrp/simulator/badge.png?branch=main)](https://coveralls.io/github/cvxgrp/simulator?branch=main)

  [![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/cvxgrp/simulator)

  Given a universe of $m$ assets we are given prices for each of them at
  time $t_1, t_2, \ldots t_n$, e.g. we operate using an $n \times m$ matrix where
  each column corresponds to a particular asset.

  In a backtest we iterate in time (e.g. row by row) through the matrix and
  allocate positions to all or some of the assets. This tool shall help to
  simplify the accounting. It keeps track of the available cash,
  the profits achieved, etc.

  ![Analytics](https://raw.githubusercontent.com/cvxgrp/simulator/main/newplot.png)



  It is possible to install cvxsimulator with the quantstats extra

  ```bash
  pip install cvxsimulator[quantstats]
  ```

  or without it

  ```bash
  pip install cvxsimulator
  ```



  The simulator shall be completely agnostic as to the trading policy/strategy.
  Our approach follows a rather common pattern:

  * [Create the builder object](#create-the-builder-object)
  * [Loop through time](#loop-through-time)
  * [Build the portfolio](#build-the-portfolio)

  We demonstrate those steps with somewhat silly policies.
  They are never good strategies, but are always valid ones.



  The user defines a builder object by loading prices
  and initialize the amount of cash used in an experiment:

  ```python
  import pandas as pd
  from cvx.simulator import Builder

  prices = pd.read_csv("prices.csv", index_col=0, parse_dates=True, header=0)
  b = Builder(prices=prices, initial_aum=1e6)
  ```

  Prices have to be valid, there may be NaNs only at the beginning and the end of
  each column in frame.
  There can be no NaNs hiding in the middle of any time series.

  It is also possible to specify a model for trading costs.
  The builder helps to fill up the frame of positions. Only once done
  we construct the actual portfolio.



  We have overloaded the `__iter__` and `__setitem__` methods to create a custom loop.
  Let's start with a first strategy. Each day we choose two names from the
  universe at random.
  Buy one (say 0.1 of your portfolio wealth) and short one the same amount.

  ```python
  for t, state in b:
      
      pair = np.random.choice(state.assets, 2, replace=False)
      
      units = pd.Series(index=state.assets, data=0.0)
      units[pair] = [state.nav, -state.nav] / state.prices[pair].values
      
      b.position = 0.1 * units
      
      b.aum = state.aum
  ```

  Here t is the growing list of timestamps, e.g. in the first iteration
  t is $t1$, in the second iteration it will be $t1, t2$ etc.

  A lot of magic is hidden in the state variable.
  The state gives access to the currently available cash, the current prices
  and the current valuation of all holdings.

  Here's a slightly more realistic loop. Given a set of $4$ assets we want to
  implemenent the popular $1/n$ strategy.

  ```python
  for t, state in b:
      
      b.position = 0.25 * state.nav / state.prices
      b.aum = state.aum
  ```

  Note that we update the position at the last element in the t list
  using a series of actual units rather than weights or cashpositions.
  The builder class also exposes setters for such alternative conventions.

  ```python
  for t, state in b:
      
      b.weights = np.ones(4)*0.25
      b.aum = state.aum
  ```



  Once finished it is possible to build the portfolio object

  ```python
  portfolio = b.build()
  ```



  The portfolio object supports further analysis and exposes
  a number of properties, e.g.

  ```python
  portfolio.nav
  portfolio.cash
  portfolio.equity
  ```

  It is possible to perform

  ```python
  portfolio.snapshot()
  ```

  We have also integrated the [quantstats](https://github.com/ranaroussi/quantstats)
  package as an optional extra for further analysis. It is usually enough to inject
  the `portfolio.nav` into the many functions exposed by this package.



  You need to install [task](https://taskfile.dev).
  Starting with

  ```bash
  task simulator:install
  ```

  will install [uv](https://github.com/astral-sh/uv) and create
  the virtual environment defined in
  pyproject.toml and locked in uv.lock.



  We install [marimo](https://marimo.io) on the fly within the aforementioned
  virtual environment. Executing

  ```bash
  task simulator:marimo
  ```

  will install and start marimo.


pkgId: b46df24afe510e0c209604dd132e1ea782a9a92b6f7e3511b4f3bf9f03af025c
name: python-cxcsvtopandas-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for cxcsvtopandas
url: https://github.com/amitgupta7/my_package
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cxcsvtopandas-0.1.0-1.src.rpm
location_href: Packages/python-cxcsvtopandas-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  A simple example package for loading and processing CSV data into Pandas DataFrames.


  You can install the `cxpandascsvloader` package using pip:

  ```sh
  pip install cxpandascsvloader
  ```


  ```sh
  import cxpandascsvloader.dataframeloader as dfl
  dfl.printinfo()


pkgId: 6593ce2830afddc188f6a7054c9c1076771241816f1214f4c9fa837e2bb5b60b
name: python-cyberdrop-dl-patched-help
arch: noarch
version: 5.7.2.post2
epoch: 0
release: 1
summary: Development documents and examples for cyberdrop-dl-patched
url: https://github.com/jbsparrow/CyberDropDownloader
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cyberdrop-dl-patched-5.7.2.post2-1.src.rpm
location_href: Packages/python-cyberdrop-dl-patched-help-5.7.2.post2-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">


  *Bulk asynchronous downloader for multiple file hosts*

  [![PyPI - Version](https://img.shields.io/pypi/v/cyberdrop-dl-patched)](https://pypi.org/project/cyberdrop-dl-patched/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cyberdrop-dl-patched)](https://pypi.org/project/cyberdrop-dl-patched/)
  [![Docs](https://img.shields.io/badge/docs-wiki-blue?link=https%3A%2F%2Fscript-ware.gitbook.io%2Fcyberdrop-dl)](https://script-ware.gitbook.io/cyberdrop-dl)
  [![GitHub License](https://img.shields.io/github/license/jbsparrow/CyberDropDownloader)](https://github.com/jbsparrow/CyberDropDownloader/blob/master/LICENSE)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/cyberdrop-dl-patched)](https://pypistats.org/packages/cyberdrop-dl-patched)

  [![Discord](https://discordapp.com/api/guilds/1070206871564197908/widget.png?style=banner2)](https://discord.com/invite/P5nsbKErwy)


  Brand new and improved! Cyberdrop-DL now has an updated paint job, fantastic new look. It's now easier to use than ever before!

  ![Cyberdrop-DL TUI Preview](docs/.gitbook/assets/cyberdrop-dl_tui_preview.png)

  </div>



  See the [list of supported sites](https://script-ware.gitbook.io/cyberdrop-dl/reference/supported-websites) on the official wiki




  Follow the [quickstart guide](https://script-ware.gitbook.io/cyberdrop-dl/quick-start) for instructions on how to install and configure Cyberdrop-DL



  If there is a feature you want, you've discovered a bug, or if you have other general feedback, please create an issue for it!

  See [CONTRIBUTING.md](CONTRIBUTING.md) for instructions on [opening an Issue](CONTRIBUTING.md#submitting-an-issue). If you want to submit code to the project, follow the [guidelines on how to contribute](CONTRIBUTING.md#submitting-a-pull-request-pr).


pkgId: 74615aa7c4429baf4e4ae789e272f22d82b949c8253012eb271fa558b030353c
name: python-cyclarity-in-vehicle-sdk-help
arch: noarch
version: 1.0.6
epoch: 0
release: 1
summary: Development documents and examples for cyclarity-in-vehicle-sdk
url: https://pypi.org/project/cyclarity-in-vehicle-sdk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cyclarity-in-vehicle-sdk-1.0.6-1.src.rpm
location_href: Packages/python-cyclarity-in-vehicle-sdk-help-1.0.6-1.noarch.rpm
checksum_type: sha256
description:
  This package provides the In-Vehicle SDK, offering a range of functionalities to support communication and operations with in-vehicle systems.



  The In-Vehicle SDK package includes the following interfaces and implementations:

  1. **CommunicatorBase**: Provides the capability to send and receive byte data over various protocols. The following implementations are available:
      * `TcpCommunicator`
      * `MulticastCommunicator`
      * `IsoTpCommunicator`
      * `DoipCommunicator`

  2. **RawSocketCommunicatorBase**: Offers send, receive, and srp (send and receive answer) operations for `py_pcapplusplus.Packet` types. The following implementations are available:
      * `Layer2RawSocket`
      * `Layer3RawSocket`

  3. **CanCommunicatorBase**: Exposes the python-can functionality, offering operations like send, receive, sniff, and more. The following implementation is available:
      * `CanCommunicatorSocketCan` - A specific implementation for the socketcan driver

  4. **DoipUtils**: A utility library for performing Diagnostic over IP (DoIP) operations, such as vehicle identity requests, routing activation, and more.

  5. **UdsUtilsBase**: Used for performing Unified Diagnostic Services (UDS) operations, such as ECU reset, read DIDs, session change, and more. The following implementation is available:
      * `UdsUtils` - Can be initialized to work over DoIP/ISO-TP

  6. **IDeviceShell**: Allows for the execution of shell commands. The following implementations are available:
      * `AdbDeviceShell`
      * `SerialDeviceShell`
      * `SshDeviceShell`



  You can install the In-Vehicle SDK package using pip:
  `pip install cyclarity-in-vehicle-sdk`


pkgId: edb9b26165fe9d0f8ab67ce3e15847f1f911d6211e78d1c10c4b29936d0b07b7
name: python-cyclarity-sdk-help
arch: noarch
version: 1.0.69
epoch: 0
release: 1
summary: Development documents and examples for cyclarity-sdk
url: https://pypi.org/project/cyclarity-sdk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cyclarity-sdk-1.0.69-1.src.rpm
location_href: Packages/python-cyclarity-sdk-help-1.0.69-1.noarch.rpm
checksum_type: sha256
description:
  Project description
  CyClarity SDK

  Introduction

  CyClarity SDK is a Python package that provides an interface for interacting with the CyClarity platform. It includes classes and methods for creating, managing, and interacting with various resources on the platform.

  Installation

  You can install the CyClarity SDK using poetry in your poetry project:

  ```bash
    poetry add cyclarity-sdk
  ```

  To create a poetry project use this docs: https://python-poetry.org/docs/

  You can download your sdk-usage-example using cyclarity git hub example : https://github.com/cyclarity/cyclarity-sdk-usage-examples
  Usage

  Here are examples of how to use the classes in the CyClarity SDK. Runnable The Runnable class is a base class for creating objects that can be run with setup and teardown phases. It has setup, run, and teardown methods that need to be implemented.

  This is the structure of a runnable:
  ```python
  from cyclarity_sdk.runnable import Runnable, BaseResultsModel
  from cyclarity_sdk.sdk_models.findings import PTFinding
  import cyclarity_sdk.sdk_models.findings.types import FindingStatus , FindingType , AssessmentCategory
  import cyclarity_sdk.sdk_models.findings.types as PTFindingTypes
  class MyResult(BaseResultsModel):
      res_str: str

  class MyRunnable(Runnable[MyResult]):
      desc: str
      cli_args: str
      
      def setup(self):
          self.logger.info("Setting up")
      
      def run(self):
          self.logger.info("Running")
          self.platform_api.send_test_report_description("This is a test description")
          self.platform_api.send_finding(PTFinding(
              topic='hello world',
              status=PTFindingTypes.FindingStatus.FINISHED,
              type=PTFindingTypes.FindingType.FINDING,
              assessment_category=PTFindingTypes.AssessmentCategory.FUNCTIONAL_TEST,
              assessment_technique=PTFindingTypes.AssessmentTechnique.OTHER_EXPLORATION,
              purpose='Snippet example',
              description='This is an example snippet on how to user platform_api'))
          for percentage in range(101):
              self.platform_api.report_test_progress(percentage=percentage)
              time.sleep(0.01)
          return MyResult(res_str="success!")

      def teardown(self, exception_type, exception_value, traceback):
          self.logger.info("Tearing down")
  ```


  The PlatformApi class provides methods for interacting with the CyClarity platform. It is used within a Runnable instance through the self.platform_api attribute.
  ```python

  from cyclarity_sdk.platform_api.Iplatform_connector import IPlatformConnectorApi as IPlatformConnectorApi
  from cyclarity_sdk.sdk_models.findings import PTFinding as PTFinding

  class PlatformApi:
      def __init__(self, platform_connector: IPlatformConnectorApi | None = None) -> None: ...
      def send_test_report_description(self, description: str): ...
      def send_finding(self, pt_finding: PTFinding): ...
      def report_test_progress(self, percentage: int): ...

  ```

  description: str (expects a description)

  Gets PTfinding object and sends it to be visible on the website (See [PTFinding](#ptfinding))

  percentage: int (expects a percentage , example above)


  ```python
  from pydantic import BaseModel, Field, computed_field, field_validator
  from enum import Enum
  from cyclarity_sdk.sdk_models.findings.types import FindingStatus, FindingType, AssessmentCategory, AssessmentTechnique
  from cyclarity_sdk.sdk_models import ExecutionMetadata, MessageType

  class PTFinding(BaseModel):
      topic: str
      status: FindingStatus
      type: FindingType
      assessment_category: AssessmentCategory
      assessment_technique: AssessmentTechnique
      purpose: str
      description: str

  class FindingStatus(str, Enum):
      FINISHED = 'Finished'
      PARTIALLY_PERFORMED = 'Partially Performed'
      NOT_PERFORMED = 'Not Performed'

  class FindingType(str, Enum):
      FINDING = 'Finding'
      NON_FINDING = 'Non Finding'
      INSIGHT = 'Insight'
      ADDITIONAL_INFORMATION = 'Additional Information'

  class AssessmentCategory(str, Enum):
      FUNCTIONAL_TEST = 'functional test'
      PENTEST = 'pentest'
      VULNERABILITY_ANALYSIS = 'vulnerability analysis'
      INCIDENT = 'incident'
      CODE_REVIEW = 'code review'
      UNKNOWN = 'unknown'

  class AssessmentTechnique(str, Enum):
      SPEC_BASED_TEST_CASE = 'specification-based test case'
      HARDWARE_ANALYSIS = 'hardware analysis'
      BINARY_ANALYSIS = 'binary analysis'
      INTERFACE_ANALYSIS = 'interface analysis'
      NETWORK_ANALYSIS = 'network analysis'
      CODE_REVIEW = 'code review'
      SPECIFICATION_REVIEW = 'specification review'
      CVE_SEARCH = 'CVE search'
      OTHER_EXPLORATION = 'other exploration'
      UNKNOWN = 'unknown'
  ```


pkgId: d55bc8e107db56c93e552ac755bbc459cbae64c40df2dc8f6dc10bd0bb9dfce7
name: python-cycode-help
arch: noarch
version: 2.1.1
epoch: 0
release: 1
summary: Development documents and examples for cycode
url: https://github.com/cycodehq/cycode-cli
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cycode-2.1.1-1.src.rpm
location_href: Packages/python-cycode-help-2.1.1-1.noarch.rpm
checksum_type: sha256
description:
  The Cycode Command Line Interface (CLI) is an application you can install on your local machine which can scan your locally stored repositories for any secrets or infrastructure as code misconfigurations.

  This guide will guide you through both installation and usage.



  1. [Prerequisites](#prerequisites)
  2. [Installation](#installation)
      1. [Install Cycode CLI](#install-cycode-cli)
          1. [Using the Auth Command](#using-the-auth-command)
          2. [Using the Configure Command](#using-the-configure-command)
          3. [Add to Environment Variables](#add-to-environment-variables)
              1. [On Unix/Linux](#on-unixlinux)
              2. [On Windows](#on-windows)
      2. [Install Pre-Commit Hook](#install-pre-commit-hook)
  3. [Cycode Command](#cycode-cli-commands)
  4. [Scan Command](#scan-command)
      1. [Running a Scan](#running-a-scan)
          1. [Repository Scan](#repository-scan)
              1. [Branch Option](#branch-option)
          2. [Monitor Option](#monitor-option)
          3. [Report Option](#report-option)
          4. [Package Vulnerabilities Scan](#package-vulnerabilities-option)
              1. [License Compliance Option](#license-compliance-option)
              2. [Severity Threshold](#severity-threshold)
          5. [Path Scan](#path-scan)
              1. [Terraform Plan Scan](#terraform-plan-scan)
          6. [Commit History Scan](#commit-history-scan)
              1. [Commit Range Option](#commit-range-option)
          7. [Pre-Commit Scan](#pre-commit-scan)
          8. [Lock Restore Options](#lock-restore-options)
              1. [SBT Scan](#sbt-scan)
      2. [Scan Results](#scan-results)
          1. [Show/Hide Secrets](#showhide-secrets)
          2. [Soft Fail](#soft-fail)
          3. [Example Scan Results](#example-scan-results)
              1. [Secrets Result Example](#secrets-result-example)
              2. [IaC Result Example](#iac-result-example)
              3. [SCA Result Example](#sca-result-example)
              4. [SAST Result Example](#sast-result-example)
          4. [Company’s Custom Remediation Guidelines](#companys-custom-remediation-guidelines)
      3. [Ignoring Scan Results](#ignoring-scan-results)
          1. [Ignoring a Secret Value](#ignoring-a-secret-value)
          2. [Ignoring a Secret SHA Value](#ignoring-a-secret-sha-value)
          3. [Ignoring a Path](#ignoring-a-path)
          4. [Ignoring a Secret, IaC, or SCA Rule](#ignoring-a-secret-iac-sca-or-sast-rule)
          5. [Ignoring a Package](#ignoring-a-package)
          6. [Ignoring using config file](#ignoring-using-config-file)
  5. [Report command](#report-command)
      1. [Generating SBOM Report](#generating-sbom-report)
  6. [Syntax Help](#syntax-help)



  - The Cycode CLI application requires Python version 3.8 or later.
  - Use the [`cycode auth` command](#using-the-auth-command) to authenticate to Cycode with the CLI
    - Alternatively, you can obtain a Cycode Client ID and Client Secret Key by following the steps detailed in the [Service Account Token](https://docs.cycode.com/reference/creating-a-service-account-access-token) and [Personal Access Token](https://docs.cycode.com/reference/creating-a-personal-access-token-1) pages, which contain details on obtaining these values.



  The following installation steps are applicable to both Windows and UNIX / Linux operating systems.

  > [!NOTE]
  > The following steps assume the use of `python3` and `pip3` for Python-related commands; however, some systems may instead use the `python` and `pip` commands, depending on your Python environment’s configuration.



  To install the Cycode CLI application on your local machine, perform the following steps:

  1. Open your command line or terminal application.

  2. Execute one of the following commands:

     - `pip3 install cycode` - to install from PyPI
     - `brew install cycode` - to install from Homebrew

  3. Navigate to the top directory of the local repository you wish to scan.

  4. There are three methods to set the Cycode client ID and client secret:

     - [cycode auth](#using-the-auth-command) (**Recommended**)
     - [cycode configure](#using-the-configure-command)
     - Add them to your [environment variables](#add-to-environment-variables)



  > [!NOTE]
  > This is the **recommended** method for setting up your local machine to authenticate with Cycode CLI.

  1. Type the following command into your terminal/command line window:

     `cycode auth`

  2. A browser window will appear, asking you to log into Cycode (as seen below):

      ![Cycode login](https://raw.githubusercontent.com/cycodehq/cycode-cli/main/images/cycode_login.png)

  3. Enter your login credentials on this page and log in.

  4. You will eventually be taken to the page below, where you'll be asked to choose the business group you want to authorize Cycode with (if applicable):

      ![authorize CLI](https://raw.githubusercontent.com/cycodehq/cycode-cli/main/images/authorize_cli.png)

     > [!NOTE]
      > This will be the default method for authenticating with the Cycode CLI.

  5. Click the **Allow** button to authorize the Cycode CLI on the selected business group.

      ![allow CLI](https://raw.githubusercontent.com/cycodehq/cycode-cli/main/images/allow_cli.png)

  6. Once completed, you'll see the following screen, if it was selected successfully:

      ![successfully auth](https://raw.githubusercontent.com/cycodehq/cycode-cli/main/images/successfully_auth.png)

  7. In the terminal/command line screen, you will see the following when exiting the browser window:

    ```bash
    Successfully logged into cycode
    ```



  > [!NOTE]
  > If you already set up your Cycode Client ID and Client Secret through the Linux or Windows environment variables, those credentials will take precedent over this method.

  1. Type the following command into your terminal/command line window:

     `cycode configure`

  2. Enter your Cycode API URL value (you can leave blank to use default value).

      ```bash
      Cycode API URL [https://api.cycode.com]: https://api.onpremise.com
      ```

  3. Enter your Cycode APP URL value (you can leave blank to use default value).

      ```bash
      Cycode APP URL [https://app.cycode.com]: https://app.onpremise.com
      ```

  4. Enter your Cycode Client ID value.

      ```bash
      Cycode Client ID []: 7fe5346b-xxxx-xxxx-xxxx-55157625c72d
      ```

  5. Enter your Cycode Client Secret value.

      ```bash
      Cycode Client Secret []: c1e24929-xxxx-xxxx-xxxx-8b08c1839a2e
      ```

  6. If the values were entered successfully, you'll see the following message:

      ```bash
      Successfully configured CLI credentials!
      ```

     or/and

      ```bash
      Successfully configured Cycode URLs!
      ```

  If you go into the `.cycode` folder under your user folder, you'll find these credentials were created and placed in the `credentials.yaml` file in that folder.
  And the URLs were placed in the `config.yaml` file in that folder.





  ```bash
  export CYCODE_CLIENT_ID={your Cycode ID}
  export CYCODE_CLIENT_SECRET={your Cycode Secret Key}
  ```



  1. From the Control Panel, navigate to the System menu:

      ![](https://raw.githubusercontent.com/cycodehq/cycode-cli/main/images/image1.png)

  2. Next, click Advanced system settings:

      ![](https://raw.githubusercontent.com/cycodehq/cycode-cli/main/images/image2.png)

  3. In the System Properties window that opens, click the Environment Variables button:

      ![](https://raw.githubusercontent.com/cycodehq/cycode-cli/main/images/image3.png)

  4. Create `CYCODE_CLIENT_ID` and `CYCODE_CLIENT_SECRET` variables with values matching your ID and Secret Key, respectively:

      ![](https://raw.githubusercontent.com/cycodehq/cycode-cli/main/images/image4.png)

  5. Insert the cycode.exe into the path to complete the installation.



  Cycode’s pre-commit hook can be set up within your local repository so that the Cycode CLI application will identify any issues with your code automatically before you commit it to your codebase.

  > [!NOTE]
  > pre-commit hook is only available to Secrets and SCA scans.

  Perform the following steps to install the pre-commit hook:

  1. Install the pre-commit framework (Python 3.8 or higher must be installed):

     `pip3 install pre-commit`

  2. Navigate to the top directory of the local Git repository you wish to configure.

  3. Create a new YAML file named `.pre-commit-config.yaml` (include the beginning `.`) in the repository’s top directory that contains the following:

      ```yaml
      repos:
        - repo: https://github.com/cycodehq/cycode-cli
          rev: v1.11.0
          hooks:
            - id: cycode
              stages:
                - commit
      ```

  4. Modify the created file for your specific needs. Use hook ID `cycode` to enable scan for Secrets. Use hook ID `cycode-sca` to enable SCA scan. If you want to enable both, use this configuration:

      ```yaml
      repos:
        - repo: https://github.com/cycodehq/cycode-cli
          rev: v1.11.0
          hooks:
            - id: cycode
              stages:
                - commit
            - id: cycode-sca
              stages:
                - commit
      ```

  5. Install Cycode’s hook:

     `pre-commit install`

     A successful hook installation will result in the message: `Pre-commit installed at .git/hooks/pre-commit`.

  6. Keep the pre-commit hook up to date:

     `pre-commit autoupdate`

     It will automatically bump "rev" in ".pre-commit-config.yaml" to the latest available version of Cycode CLI.

  > [!NOTE]
  > Trigger happens on `git commit` command.
  > Hook triggers only on the files that are staged for commit.



  The following are the options and commands available with the Cycode CLI application:

  | Option                               | Description                                                        |
  |--------------------------------------|--------------------------------------------------------------------|
  | `-o`, `--output [text\|json\|table]` | Specify the output (`text`/`json`/`table`). The default is `text`. |
  | `-v`, `--verbose`                    | Show detailed logs.                                                |
  | `--help`                             | Show options for given command.                                    |

  | Command                                   | Description                                                                                                                           |
  |-------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------|
  | [auth](#using-the-auth-command)           | Authenticates your machine to associate CLI with your Cycode account.                                                                 |
  | [configure](#using-the-configure-command) | Initial command to authenticate your CLI client with Cycode using client ID and client secret.                                        |
  | [ignore](#ignoring-scan-results)          | Ignore a specific value, path or rule ID.                                                                                             |
  | [scan](#running-a-scan)                   | Scan content for secrets/IaC/SCA/SAST violations. You need to specify which scan type: `ci`/`commit_history`/`path`/`repository`/etc. |
  | [report](#report-command)                 | Generate report for SCA SBOM.                                                                                                         |
  | version                                   | Show the version and exit.                                                                                                            |





  The Cycode CLI application offers several types of scans so that you can choose the option that best fits your case. The following are the current options and commands available:

  | Option                                                     | Description                                                                                                                                                                                                                                             |
  |------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | `-t, --scan-type [secret\|iac\|sca\|sast]`                 | Specify the scan you wish to execute (`secret`/`iac`/`sca`/`sast`), the default is `secret`                                                                                                                                                             |
  | `--secret TEXT`                                            | Specify a Cycode client secret for this specific scan execution                                                                                                                                                                                         |
  | `--client-id TEXT`                                         | Specify a Cycode client ID for this specific scan execution                                                                                                                                                                                             |
  | `--show-secret BOOLEAN`                                    | Show secrets in plain text. See [Show/Hide Secrets](#showhide-secrets) section for more details.                                                                                                                                                        |
  | `--soft-fail BOOLEAN`                                      | Run scan without failing, always return a non-error status code. See [Soft Fail](#soft-fail) section for more details.                                                                                                                                  |
  | `--severity-threshold [INFO\|LOW\|MEDIUM\|HIGH\|CRITICAL]` | Show only violations at the specified level or higher.                                                                                                                                                                                                  |
  | `--sca-scan`                                               | Specify the SCA scan you wish to execute (`package-vulnerabilities`/`license-compliance`). The default is both                                                                                                                                          |
  | `--monitor`                                                | When specified, the scan results will be recorded in the knowledge graph. Please note that when working in `monitor` mode, the knowledge graph will not be updated as a result of SCM events (Push, Repo creation). (Supported for SCA scan type only). |
  | `--report`                                                 | When specified, a violations report will be generated. A URL link to the report will be printed as an output to the command execution                                                                                                                   |
  | `--no-restore`                                             | When specified, Cycode will not run restore command. Will scan direct dependencies ONLY!                                                                                                                                                                |
  | `--help`                                                   | Show options for given command.                                                                                                                                                                                                                         |

  | Command                                | Description                                                     |
  |----------------------------------------|-----------------------------------------------------------------|
  | [commit_history](#commit-history-scan) | Scan all the commits history in this git repository             |
  | [path](#path-scan)                     | Scan the files in the path supplied in the command              |
  | [pre_commit](#pre-commit-scan)         | Use this command to scan the content that was not committed yet |
  | [repository](#repository-scan)         | Scan git repository including its history                       |



  A repository scan examines an entire local repository for any exposed secrets or insecure misconfigurations. This more holistic scan type looks at everything: the current state of your repository and its commit history. It will look not only for secrets that are currently exposed within the repository but previously deleted secrets as well.

  To execute a full repository scan, execute the following:

  `cycode scan repository {{path}}`

  For example, consider a scenario in which you want to scan your repository stored in `~/home/git/codebase`. You could then execute the following:

  `cycode scan repository ~/home/git/codebase`

  The following option is available for use with this command:

  | Option              | Description                                            |
  |---------------------|--------------------------------------------------------|
  | `-b, --branch TEXT` | Branch to scan, if not set scanning the default branch |



  To scan a specific branch of your local repository, add the argument `-b` (alternatively, `--branch`) followed by the name of the branch you wish to scan.

  Consider the previous example. If you wanted to only scan a branch named `dev`, you could execute the following:

  `cycode scan repository ~/home/git/codebase -b dev`

  or:

  `cycode scan repository ~/home/git/codebase --branch dev`



  > [!NOTE]
  > This option is only available to SCA scans.

  To push scan results tied to the [SCA policies](https://docs.cycode.com/docs/sca-policies) found in an SCA type scan to Cycode's knowledge graph, add the argument `--monitor` to the scan command.

  Consider the following example. The following command will scan the repository for SCA policy violations and push them to Cycode:

  `cycode scan -t sca --monitor repository ~/home/git/codebase`

  or:

  `cycode scan --scan-type sca --monitor repository ~/home/git/codebase`

  When using this option, the scan results from this scan will appear in the knowledge graph, which can be found [here](https://app.cycode.com/query-builder).

  > [!WARNING]
  > You must be an `owner` or an `admin` in Cycode to view the knowledge graph page.



  > [!NOTE]
  > This option is not available to IaC scans.

  To push scan results tied to the [SCA policies](https://docs.cycode.com/docs/sca-policies) found in the Repository scan to Cycode, add the argument `--report` to the scan command.

  `cycode scan -t sca --report repository ~/home/git/codebase`
  `cycode scan -t secret --report repository ~/home/git/codebase`

  or:

  `cycode scan --scan-type sca --report repository ~/home/git/codebase`
  `cycode scan --scan-type secret --report repository ~/home/git/codebase`

  When using this option, the scan results from this scan will appear in the On-Demand Scans section of Cycode. To get to this page, click the link that appears after the printed results:

  > :warning: **NOTE**<br/>
  > You must be an `owner` or an `admin` in Cycode to view this page.

  ![cli-report](https://raw.githubusercontent.com/cycodehq/cycode-cli/main/images/sca_report_url.png)


  The report page will look something like below:

  ![](https://raw.githubusercontent.com/cycodehq/cycode-cli/main/images/scan_details.png)



  > [!NOTE]
  > This option is only available to SCA scans.

  To scan a specific package vulnerability of your local repository, add the argument `--sca-scan package-vulnerabilities` following the `-t sca` or `--scan-type sca` option.

  Consider the previous example. If you wanted to only run an SCA scan on package vulnerabilities, you could execute the following:

  `cycode scan -t sca --sca-scan package-vulnerabilities repository ~/home/git/codebase`

  or:

  `cycode scan --scan-type sca --sca-scan package-vulnerabilities repository ~/home/git/codebase`



  > [!NOTE]
  > This option is only available to SCA scans.

  To scan a specific branch of your local repository, add the argument `--sca-scan license-compliance` followed by the name of the branch you wish to scan.

  Consider the previous example. If you wanted to only scan a branch named `dev`, you could execute the following:

  `cycode scan -t sca --sca-scan license-compliance repository ~/home/git/codebase -b dev`

  or:

  `cycode scan --scan-type sca --sca-scan license-compliance repository ~/home/git/codebase`



  > [!NOTE]
  > This option is only available to SCA scans.

  To limit the results of the `sca` scan to a specific severity threshold, add the argument `--severity-threshold` to the scan command.

  Consider the following example. The following command will scan the repository for SCA policy violations that have a severity of Medium or higher:

  `cycode scan -t sca --security-threshold MEDIUM repository ~/home/git/codebase`

  or:

  `cycode scan --scan-type sca --security-threshold MEDIUM repository ~/home/git/codebase`



  A path scan examines a specific local directory and all the contents within it, instead of focusing solely on a GIT repository.

  To execute a directory scan, execute the following:

  `cycode scan path {{path}}`

  For example, consider a scenario in which you want to scan the directory located at `~/home/git/codebase`. You could then execute the following:

  `cycode scan path ~/home/git/codebase`




  Cycode CLI supports Terraform plan scanning (supporting Terraform 0.12 and later)

  Terraform plan file must be in JSON format (having `.json` extension)

  _How to generate a Terraform plan from Terraform configuration file?_

  1. Initialize a working directory that contains Terraform configuration file:

      `terraform init`

  2. Create Terraform execution plan and save the binary output:

      `terraform plan -out={tfplan_output}`

  3. Convert the binary output file into readable JSON:

      `terraform show -json {tfplan_output} > {tfplan}.json`

  4. Scan your `{tfplan}.json` with Cycode CLI:

      `cycode scan -t iac path ~/PATH/TO/YOUR/{tfplan}.json`



  A commit history scan is limited to a local repository’s previous commits, focused on finding any secrets within the commit history, instead of examining the repository’s current state.

  To execute a commit history scan, execute the following:

  `cycode scan commit_history {{path}}`

  For example, consider a scenario in which you want to scan the commit history for a repository stored in `~/home/git/codebase`. You could then execute the following:

  `cycode scan commit_history ~/home/git/codebase`

  The following options are available for use with this command:

  | Option                    | Description                                                                                              |
  |---------------------------|----------------------------------------------------------------------------------------------------------|
  | `-r, --commit_range TEXT` | Scan a commit range in this git repository, by default cycode scans all commit history (example: HEAD~1) |



  The commit history scan, by default, examines the repository’s entire commit history, all the way back to the initial commit. You can instead limit the scan to a specific commit range by adding the argument `--commit_range` followed by the name you specify.

  Consider the previous example. If you wanted to scan only specific commits on your repository, you could execute the following:

  `cycode scan commit_history -r {{from-commit-id}}...{{to-commit-id}} ~/home/git/codebase`

  OR

  `cycode scan commit_history --commit_range {{from-commit-id}}...{{to-commit-id}} ~/home/git/codebase`



  A pre-commit scan automatically identifies any issues before you commit changes to your repository. There is no need to manually execute this scan; simply configure the pre-commit hook as detailed under the Installation section of this guide.

  After your install the pre-commit hook and, you may, on occasion, wish to skip scanning during a specific commit. Simply add the following to your `git` command to skip scanning for a single commit:

  `SKIP=cycode git commit -m <your commit message>`





  We use sbt-dependency-lock plugin to restore the lock file for SBT projects.
  To disable lock restore in use `--no-restore` option.

  Prerequisites
  * sbt-dependency-lock Plugin: Install the plugin by adding the following line to `project/plugins.sbt`:
  `addSbtPlugin("software.purpledragon" % "sbt-dependency-lock" % "1.5.1")`



  Each scan will complete with a message stating if any issues were found or not.

  If no issues are found, the scan ends with the following success message:

  `Good job! No issues were found!!! 👏👏👏`

  If an issue is found, a `Found issue of type:` message appears upon completion instead:

  ```bash
  ⛔  Found issue of type: generic-password (rule ID: ce3a4de0-9dfc-448b-a004-c538cf8b4710) in file: config/my_config.py
  Secret SHA: a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0  ⛔
  0 | @@ -0,0 +1 @@
  1 | +my_password = 'h3l***********350'
  2 | \ No newline at end of file
  ```

  In the event an issue is found, review the file in question for the specific line highlighted by the result message. Implement any changes required to resolve the issue, then execute the scan again.



  In the above example, a secret was found in the file `secret_test`, located in the subfolder `cli`. The second part of the message shows the specific line the secret appears in, which in this case is a value assigned to `googleApiKey`.

  Note how the above example obscures the actual secret value, replacing most of the secret with asterisks. Scans obscure secrets by default, but you may optionally disable this feature in order to view the full secret (assuming the machine you are viewing the scan result on is sufficiently secure from prying eyes).

  To disable secret obfuscation, add the `--show-secret` argument to any type of scan, then assign it a `1` value to show the full secret in the result message, or `0` to hide the secret (which is done by default).

  In the following example, a Path Scan is executed against the `cli` subdirectory with the option enabled to display any secrets found in full:

  `cycode scan --show-secret=1 path ./cli`

  The result would then not be obfuscated:

  ```bash
  ⛔  Found issue of type: generic-password (rule ID: ce3a4de0-9dfc-448b-a004-c538cf8b4710) in file: config/my_config.py
  Secret SHA: a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0  ⛔
  0 | @@ -0,0 +1 @@
  1 | +my_password = 'h3110w0r1d!@#$350'
  2 | \ No newline at end of file
  ```



  Using the soft fail feature will not fail the CI/CD step within the pipeline if the Cycode scan detects an issue.
  If an issue occurs during the Cycode scan, using a soft fail feature will automatically execute with success (`0`) to avoid interference.

  To configure this feature, add the `--soft-fail` option to any type of scan. This will force the scan results to succeed (exit code `0`).

  Scan results are assigned with a value of exit code `1` when issues are found in the scan results; this will result in a failure within the CI/CD tool. Use the option `--soft-fail` to force the results with the exit code `0` to have no impact (i.e., to have a successful result).





  ```bash
  ⛔  Found issue of type: generic-password (rule ID: ce3a4de0-9dfc-448b-a004-c538cf8b4710) in file: config/my_config.py
  Secret SHA: a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0  ⛔
  0 | @@ -0,0 +1 @@
  1 | +my_password = 'h3l***********350'
  2 | \ No newline at end of file
  ```



  ```bash
  ⛔  Found issue of type: Resource should use non-default namespace (rule ID: bdaa88e2-5e7c-46ff-ac2a-29721418c59c) in file: ./k8s/k8s.yaml   ⛔

  7 |   name: secrets-file
  8 |   namespace: default
  9 |   resourceVersion: "4228"
  ```



  ```bash
  ⛔  Found issue of type: Security vulnerability in package 'pyyaml' referenced in project 'Users/myuser/my-test-repo': Improper Input Validation in PyYAML (rule ID: d003b23a-a2eb-42f3-83c9-7a84505603e5) in file: Users/myuser/my-test-repo/requirements.txt   ⛔

  1 | PyYAML~=5.3.1
  2 | vyper==0.3.1
  3 | cleo==1.0.0a5
  ```



  ```bash
  ⛔  Found issue of type: Detected a request using 'http://'. This request will be unencrypted, and attackers could listen into traffic on the network and be able to obtain sensitive information. Use 'https://' instead. (rule ID: 3fbbd34b-b00d-4415-b9d9-f861c076b9f2) in file: ./requests.py   ⛔

  2 |
  3 | res = requests.get('http://example.com', timeout=1)
  4 | print(res.content)
  ```



  If your company has set custom remediation guidelines in the relevant policy via the Cycode portal, you'll see a field for “Company Guidelines” that contains the remediation guidelines you added. Note that if you haven't added any company guideline, this field will not appear in the CLI tool.



  Ignore rules can be added to ignore specific secret values, specific SHA512 values, specific paths, and specific Cycode secret and IaC rule IDs. This will cause the scan to not alert these values. The ignore rules are written and saved locally in the `./.cycode/config.yaml` file.

  > :warning: **Warning**<br/>
  > Adding values to be ignored should be done with careful consideration of the values, paths, and policies to ensure that the scans will pick up true positives.

  The following are the options available for the `cycode ignore` command:

  | Option                                     | Description                                                                                                                                                              |
  |--------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | `--by-value TEXT`                          | Ignore a specific value while scanning for secrets. See [Ignoring a Secret Value](#ignoring-a-secret-value) for more details.                                            |
  | `--by-sha TEXT`                            | Ignore a specific SHA512 representation of a string while scanning for secrets. See [Ignoring a Secret SHA Value](#ignoring-a-secret-sha-value) for more details.        |
  | `--by-path TEXT`                           | Avoid scanning a specific path. Need to specify scan type. See [Ignoring a Path](#ignoring-a-path) for more details.                                                     |
  | `--by-rule TEXT`                           | Ignore scanning a specific secret rule ID/IaC rule ID/SCA rule ID. See [Ignoring a Secret or Iac Rule](#ignoring-a-secret-iac-sca-or-sast-rule) for more details.        |
  | `--by-package TEXT`                        | Ignore scanning a specific package version while running an SCA scan. Expected pattern - `name@version`. See [Ignoring a Package](#ignoring-a-package) for more details. |
  | `-t, --scan-type [secret\|iac\|sca\|sast]` | Specify the scan you wish to execute (`secret`/`iac`/`sca`/`sast`), The default value is `secret`                                                                        |
  | `-g, --global`                             | Add an ignore rule and update it in the global `.cycode` config file                                                                                                     |

  In the following example, a pre-commit scan runs and finds the following:

  ```bash
  ⛔  Found issue of type: generic-password (rule ID: ce3a4de0-9dfc-448b-a004-c538cf8b4710) in file: config/my_config.py
  Secret SHA: a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0  ⛔
  0 | @@ -0,0 +1 @@
  1 | +my_password = 'h3l***********350'
  2 | \ No newline at end of file
  ```

  If this is a value that is not a valid secret, then use the `cycode ignore` command to ignore the secret by its value, SHA value, specific path, or rule ID. If this is an IaC scan, then you can ignore that result by its path or rule ID.



  To ignore a specific secret value, you will need to use the `--by-value` flag. This will ignore the given secret value from all future scans. Use the following command to add a secret value to be ignored:

  `cycode ignore --by-value {{secret-value}}`

  In the example at the top of this section, the command to ignore a specific secret value is as follows:

  `cycode ignore --by-value h3110w0r1d!@#$350`

  In the example above, replace the `h3110w0r1d!@#$350` value with your non-masked secret value. See the Cycode scan options for details on how to see secret values in the scan results.



  To ignore a specific secret SHA value, you will need to use the `--by-sha` flag. This will ignore the given secret SHA value from all future scans. Use the following command to add a secret SHA value to be ignored:

  `cycode ignore --by-sha {{secret-sha-value}}`

  In the example at the top of this section, the command to ignore a specific secret SHA value is as follows:

  `cycode ignore --by-sha a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0`

  In the example above, replace the `a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0` value with your secret SHA value.



  To ignore a specific path for either secret, IaC, or SCA scans, you will need to use the `--by-path` flag in conjunction with the `-t, --scan-type` flag (you must specify the scan type). This will ignore the given path from all future scans for the given scan type. Use the following command to add a path to be ignored:

  `cycode ignore -t {{scan-type}} --by-path {{path}}`

  OR

  `cycode ignore --scan-type {{scan-type}} --by-path {{path}}`

  In the example at the top of this section, the command to ignore a specific path for a secret is as follows:

  `cycode ignore -t secret --by-path ~/home/my-repo/config`

  In the example above, replace the `~/home/my-repo/config` value with your path value.

  In the example at the top of this section, the command to ignore a specific path from IaC scans is as follows:

  `cycode ignore -t iac --by-path ~/home/my-repo/config`

  In the example above, replace the `~/home/my-repo/config` value with your path value.

  In the example at the top of this section, the command to ignore a specific path from SCA scans is as follows:

  `cycode ignore -t sca --by-path ~/home/my-repo/config`

  In the example above, replace the `~/home/my-repo/config` value with your path value.



  To ignore a specific secret, IaC, SCA, or SAST rule, you will need to use the `--by-rule` flag in conjunction with the `-t, --scan-type` flag (you must specify the scan type). This will ignore the given rule ID value from all future scans. Use the following command to add a rule ID value to be ignored:

  `cycode ignore -t {{scan-type}} --by-rule {{rule-ID}}`

  OR

  `cycode ignore --scan-type {{scan-type}} --by-rule {{rule-ID}}`

  In the example at the top of this section, the command to ignore the specific secret rule ID is as follows:

  `cycode ignore --scan-type secret --by-rule ce3a4de0-9dfc-448b-a004-c538cf8b4710`

  In the example above, replace the `ce3a4de0-9dfc-448b-a004-c538cf8b4710` value with the rule ID you want to ignore.

  In the example at the top of this section, the command to ignore the specific IaC rule ID is as follows:

  `cycode ignore --scan-type iac --by-rule bdaa88e2-5e7c-46ff-ac2a-29721418c59c`

  In the example above, replace the `bdaa88e2-5e7c-46ff-ac2a-29721418c59c` value with the rule ID you want to ignore.

  In the example at the top of this section, the command to ignore the specific SCA rule ID is as follows:

  `cycode ignore --scan-type sca --by-rule dc21bc6b-9f4f-46fb-9f92-e4327ea03f6b`

  In the example above, replace the `dc21bc6b-9f4f-46fb-9f92-e4327ea03f6b` value with the rule ID you want to ignore.



  > [!NOTE]
  > This option is only available to the SCA scans.

  To ignore a specific package in the SCA scans, you will need to use the `--by-package` flag in conjunction with the `-t, --scan-type` flag (you must specify the `sca` scan type). This will ignore the given package, using the `{{package_name}}@{{package_version}}` formatting, from all future scans. Use the following command to add a package and version to be ignored:

  `cycode ignore --scan-type sca --by-package {{package_name}}@{{package_version}}`

  OR

  `cycode ignore -t sca --by-package {{package_name}}@{{package_version}}`

  In the example below, the command to ignore a specific SCA package is as follows:

  `cycode ignore --scan-type sca --by-package pyyaml@5.3.1`

  In the example above, replace `pyyaml` with package name and `5.3.1` with the package version you want to ignore.



  The applied ignoring rules are stored in the configuration file called `config.yaml`.
  This file could be easily shared between developers or even committed to remote Git.
  These files are always located in the `.cycode` folder.
  The folder starts with a dot (.), and you should enable the displaying of hidden files to see it.



  By default, all `cycode ignore` commands save the ignoring rule to the current directory from which CLI has been run.

  Example: running ignoring CLI command from `/Users/name/projects/backend` will create `config.yaml` in `/Users/name/projects/backend/.cycode`

  ```shell
  ➜  backend  pwd
  /Users/name/projects/backend
  ➜  backend  cycode ignore --by-value test-value
  ➜  backend  tree -a
  .
  └── .cycode
      └── config.yaml

  2 directories, 1 file
  ```

  The second option is to save ignoring rules to the global configuration files.
  The path of the global config is `~/.cycode/config.yaml`,
  where `~` means user\`s home directory, for example, `/Users/name` on macOS.

  Saving to the global space could be performed with the `-g` flag of the `cycode ignore` command.
  For example: `cycode ignore -g --by-value test-value`.



  This is incredibly important to place the `.cycode` folder and run CLI from the same place.
  You should double-check it when working with different environments like CI/CD (GitHub Actions, Jenkins, etc.).

  You could commit the `.cycode` folder to the root of your repository.
  In this scenario, you must run CLI scans from the repository root.
  If it doesn't fit your requirements, you could temporarily copy the `.cycode` folder
  wherever you want and perform a CLI scan from this folder.



  It's important to understand how CLI stores ignore rules to be able to read these configuration files or even modify them without CLI.

  The abstract YAML structure:
  ```yaml
  exclusions:
    *scanTypeName*:
      *ignoringType:
      - *ignoringValue1*
      - *ignoringValue2*
  ```

  Possible values of `scanTypeName`: `iac`, `sca`, `sast`, `secret`.
  Possible values of `ignoringType`: `paths`, `values`, `rules`, `packages`, `shas`.

  > [!WARNING]
  > Values for "ignore by value" are not stored as plain text!
  > CLI stores sha256 hashes of the values instead.
  > You should put hashes of the string when modifying the configuration file by hand.

  Example of real `config.yaml`:
  ```yaml
  exclusions:
    iac:
      rules:
      - bdaa88e2-5e7c-46ff-ac2a-29721418c59c
    sca:
      packages:
      - pyyaml@5.3.1
    secret:
      paths:
      - /Users/name/projects/build
      rules:
      - ce3a4de0-9dfc-448b-a004-c538cf8b4710
      shas:
      - a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0
      values:
      - a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3
      - 60303ae22b998861bce3b28f33eec1be758a213c86c93c076dbe9f558c11c752
  ```





  A software bill of materials (SBOM) is an inventory of all constituent components and software dependencies involved in the development and delivery of an application.
  Using this command you can create an SBOM report for your local project or for your repository URI.

  The following options are available for use with this command:

  | Option                                             | Description                    | Required | Default                                               |
  |----------------------------------------------------|--------------------------------|----------|-------------------------------------------------------|
  | `-f, --format [spdx-2.2\|spdx-2.3\|cyclonedx-1.4]` | SBOM format                    | Yes      |                                                       |
  | `-o, --output-format [JSON]`                       | Specify the output file format | No       | json                                                  |
  | `--output-file PATH`                               | Output file                    | No       | autogenerated filename saved to the current directory |
  | `--include-vulnerabilities`                        | Include vulnerabilities        | No       | False                                                 |
  | `--include-dev-dependencies`                       | Include dev dependencies       | No       | False                                                 |

  The following commands are available for use with this command:

  | Command          | Description                                                     |
  |------------------|-----------------------------------------------------------------|
  | `path`           | Generate SBOM report for provided path in the command           |
  | `repository_url` | Generate SBOM report for provided repository URI in the command |



  To create an SBOM report for a repository URI:\
  `cycode report sbom --format <sbom format> --include-vulnerabilities --include-dev-dependencies --output-file </path/to/file> repository_url <repository url>`

  For example:\
  `cycode report sbom --format spdx-2.3 --include-vulnerabilities --include-dev-dependencies repository_url https://github.com/cycodehq/cycode-cli.git`



  To create an SBOM report for a path:\
  `cycode report sbom --format <sbom format> --include-vulnerabilities --include-dev-dependencies --output-file </path/to/file> path </path/to/project>`

  For example:\
  `cycode report sbom --format spdx-2.3 --include-vulnerabilities --include-dev-dependencies path /path/to/local/project`



  You may add the `--help` argument to any command at any time to see a help message that will display available options and their syntax.

  To see general help, simply enter the command:

  `cycode --help`

  To see scan options, enter:

  `cycode scan --help`

  To see the options available for a specific type of scan, enter:

  `cycode scan {{option}} --help`

  For example, to see options available for a Path Scan, you would simply enter:

  `cycode scan path --help`

  To see the options available for the ignore scan function, use this command:

  `cycode ignore --help`

  To see the options available for report, use this command:

  `cycode report --help`


  To see the options available for a specific type of report, enter:

  `cycode scan {{option}} --help`


pkgId: efc572fa93e29d51e138296cb59f00175beb906345e4d78f0a8af05ebd92c23e
name: python-cytimes-debuginfo
arch: aarch64
version: 2.0.2
epoch: 0
release: 1
summary: Debug information for package python-cytimes
url: https://github.com/AresJef/cyTimes
rpm_license: MIT license, Apache License 2.0, BSD 3-Clause
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-cytimes-2.0.2-1.src.rpm
location_href: Packages/python-cytimes-debuginfo-2.0.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-cytimes.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 632a40691a0e5d87e3c0956822b3440059f59e39eb5c1e150d20a532ff537e9b
name: python-cytimes-debugsource
arch: aarch64
version: 2.0.2
epoch: 0
release: 1
summary: Debug sources for package python-cytimes
url: https://github.com/AresJef/cyTimes
rpm_license: MIT license, Apache License 2.0, BSD 3-Clause
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-cytimes-2.0.2-1.src.rpm
location_href: Packages/python-cytimes-debugsource-2.0.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-cytimes.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 9586bfde01590de55a39a6783acff9c2b39fc4d9556ca1ee640204230c107078
name: python-cytimes-help
arch: aarch64
version: 2.0.2
epoch: 0
release: 1
summary: Development documents and examples for cytimes
url: https://github.com/AresJef/cyTimes
rpm_license: MIT license, Apache License 2.0, BSD 3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cytimes-2.0.2-1.src.rpm
location_href: Packages/python-cytimes-help-2.0.2-1.aarch64.rpm
checksum_type: sha256
description:
  Created to be used in a project, this package is published to github for ease of management and installation across different modules.



  Install from `PyPi`

  ```bash
  pip install cytimes
  ```

  Install from `github`

  ```bash
  pip install git+https://github.com/AresJef/cyTimes.git
  ```



  Supports Python 3.10 and above.



  `cyTimes` introduces two classes that simplify and enhance working with datetimes:

  - `Pydt` (Python datetime.datetime)
  - `Pddt` (Pandas DatetimeIndex)

  Both provide similar functionalities:

  - Direct drop-in replacements (subclasses) for standard Python `datetime` and Pandas `DatetimeIndex`.
  - Cython-optimized for high-performance parsing, creation, and manipulation.
  - Well-documented methods with type annotations.
  - Flexible constructors accepting multiple input formats (strings, datetime objects, timestamps, etc.).
  - Rich conversion options (ISO strings, ordinals, timestamps, and more).
  - Comprehensive manipulation for precise datetime fields adjustments (years, quarters, months, days, time).
  - Direct calendar information insights (e.g., days in month, leap years).
  - Extended timezone-related capabilities.
  - Supports adding or subtracting deltas, and compute deltas against datetime-like object(s).



  The `Pydt` class operates similarly to Python’s native `datetime.datetime`, with added methods and improvements.



  ```python
  from cytimes import Pydt
  import datetime, numpy as np

  Pydt(1970, 1, 1, tzinfo="UTC")
  >>> 1970-01-01 00:00:00+0000
  Pydt.parse("1970 Jan 1 00:00:01 PM")
  >>> 1970-01-01 12:00:01
  Pydt.now()
  >>> 2024-12-06 10:37:25.619593
  Pydt.utcnow()
  >>> 2024-12-06 09:37:36.743159+0000
  Pydt.combine("1970-01-01", "00:00:01")
  >>> 1970-01-01 00:00:01
  Pydt.fromordinal(1)
  >>> 0001-01-01 00:00:00
  Pydt.fromseconds(1)
  >>> 1970-01-01 00:00:01
  Pydt.fromicroseconds(1)
  >>> 1970-01-01 00:00:00.000001
  Pydt.fromtimestamp(1, datetime.UTC)
  >>> 1970-01-01 00:00:01+0000
  Pydt.utcfromtimestamp(1)
  >>> 1970-01-01 00:00:01+0000
  Pydt.fromisoformat("1970-01-01T00:00:01")
  >>> 1970-01-01 00:00:01
  Pydt.fromisocalendar(1970, 1, 4)
  >>> 1970-01-01 00:00:00
  Pydt.fromdate(datetime.date(1970, 1, 1))
  >>> 1970-01-01 00:00:00
  Pydt.fromdatetime(datetime.datetime(1970, 1, 1))
  >>> 1970-01-01 00:00:00
  Pydt.fromdatetime64(np.datetime64(1, "s"))
  >>> 1970-01-01 00:00:01
  Pydt.strptime("00:00:01 1970-01-01", "%H:%M:%SOURCE%Y-%m-%d")
  >>> 1970-01-01 00:00:01
  ```



  ```python
  from cytimes import Pydt

  dt = Pydt(1970, 1, 1, tzinfo="CET")

  dt.ctime()
  >>>  "Thu Jan  1 00:00:00 1970"
  dt.strftime("%Y-%m-%d %H:%M:%SOURCE%Z")
  >>>  "1970-01-01 00:00:00 CET"
  dt.isoformat()
  >>>  "1970-01-01T00:00:00+01:00"
  dt.timetuple()
  >>> (1970, 1, 1, 0, 0, 0, 3, 1, 0)
  dt.toordinal()
  >>>  719163
  dt.seconds()
  >>>  0.0
  dt.microseconds()
  >>>  0
  dt.timestamp()
  >>>  -3600.0
  dt.date()
  >>>  1970-01-01
  dt.time()
  >>>  00:00:00
  dt.timetz()
  >>>  00:00:00
  ```



  ```python
  from cytimes import Pydt

  dt = Pydt(1970, 2, 2, 2, 2, 2, 2, "CET")


  dt.replace(year=2007, microsecond=1, tzinfo="UTC")
  >>> 2007-02-02 02:02:02.000001+0000


  dt.to_curr_year(3, 15)
  >>> 1970-03-15 02:02:02.000002+0100
  dt.to_prev_year("Feb", 30)
  >>> 1969-02-28 02:02:02.000002+0100
  dt.to_next_year("十二月", 31)
  >>> 1971-12-31 02:02:02.000002+0100
  dt.to_year(100, "noviembre", 30)
  >>> 2070-11-30 02:02:02.000002+0100


  dt.to_curr_quarter(3, 15)
  >>> 1970-03-15 02:02:02.000002+0100
  dt.to_prev_quarter(3, 15)
  >>> 1969-12-15 02:02:02.000002+0100
  dt.to_next_quarter(3, 15)
  >>> 1970-06-15 02:02:02.000002+0100
  dt.to_quarter(100, 3, 15)
  >>> 1995-03-15 02:02:02.000002+0100


  dt.to_curr_month(15)
  >>> 1970-02-15 02:02:02.000002+0100
  dt.to_prev_month(15)
  >>> 1970-01-15 02:02:02.000002+0100
  dt.to_next_month(15)
  >>> 1970-03-15 02:02:02.000002+0100
  dt.to_month(100, 15)
  >>> 1978-06-15 02:02:02.000002+0200


  dt.to_monday()
  >>> 1970-02-02 02:02:02.000002+0100
  dt.to_sunday()
  >>> 1970-02-08 02:02:02.000002+0100
  dt.to_curr_weekday(4)
  >>> 1970-02-06 02:02:02.000002+0100
  dt.to_prev_weekday(4)
  >>> 1970-01-30 02:02:02.000002+0100
  dt.to_next_weekday(4)
  >>> 1970-02-13 02:02:02.000002+0100
  dt.to_weekday(100, 4)
  >>> 1972-01-07 02:02:02.000002+0100


  dt.to_yesterday()
  >>> 1970-02-01 02:02:02.000002+0100
  dt.to_tomorrow()
  >>> 1970-02-03 02:02:02.000002+0100
  dt.to_day(100)
  >>> 1970-05-13 02:02:02.000002+0100


  dt.to_first_of("Y")
  >>> 1970-01-01 02:02:02.000002+0100
  dt.to_last_of("Q")
  >>> 1970-03-31 02:02:02.000002+0100
  dt.to_start_of("M")
  >>> 1970-02-01 00:00:00+0100
  dt.to_end_of("W")
  >>> 1970-02-08 23:59:59.999999+0100


  dt.round("h")
  >>> 1970-02-02 02:00:00+0100
  dt.ceil("m")
  >>> 1970-02-02 02:03:00+0100
  dt.floor("s")
  >>> 1970-02-02 02:02:02+0100
  ```



  ```python
  from cytimes import Pydt

  dt = Pydt(1970, 2, 2, tzinfo="UTC")


  dt.isocalendar()
  >>> {'year': 1970, 'week': 6, 'weekday': 1}
  dt.isoyear()
  >>> 1970
  dt.isoweek()
  >>> 6
  dt.isoweekday()
  >>> 1


  dt.is_leap_year()
  >>> False
  dt.is_long_year()
  >>> True
  dt.leap_bt_year(2007)
  >>> 9
  dt.days_in_year()
  >>> 365
  dt.days_bf_year()
  >>> 719162
  dt.days_of_year()
  >>> 33
  dt.is_year(1970)
  >>> True


  dt.days_in_quarter()
  >>> 90
  dt.days_bf_quarter()
  >>> 0
  dt.days_of_quarter()
  >>> 33
  dt.is_quarter(1)
  >>> True


  dt.days_in_month()
  >>> 28
  dt.days_bf_month()
  >>> 31
  dt.days_of_month()
  >>> 2
  dt.is_month("Feb")
  >>> True
  dt.month_name("es")
  >>> "febrero"


  dt.is_weekday("Monday")
  >>> True


  dt.is_day(2)
  >>> True
  dt.day_name("fr")
  >>> "lundi"


  dt.is_first_of("Y")
  >>> False
  dt.is_last_of("Q")
  >>> False
  dt.is_start_of("M")
  >>> False
  dt.is_end_of("W")
  >>> False
  ```



  ```python
  from cytimes import Pydt

  dt = Pydt(1970, 1, 1, tzinfo="UTC")

  dt.is_local()
  >>> False
  dt.is_utc()
  >>> True
  dt.is_dst()
  >>> False
  dt.tzname()
  >>> "UTC"
  dt.utcoffset()
  >>> 0:00:00
  dt.utcoffset_seconds()
  >>> 0
  dt.dst()
  >>> None
  dt.astimezone("CET")
  >>> 1970-01-01 01:00:00+0100
  dt.tz_localize(None)
  >>> 1970-01-01 00:00:00
  dt.tz_convert("CET")
  >>> 1970-01-01 01:00:00+0100
  dt.tz_switch("CET")
  >>> 1970-01-01 01:00:00+0100
  ```



  ```python
  from cytimes import Pydt

  dt = Pydt(1970, 1, 1, tzinfo="UTC")

  dt.add(years=1, weeks=1, microseconds=1)
  >>> 1971-01-08 00:00:00.000001+0000
  dt.sub(quarters=1, days=1, seconds=1)
  >>> 1969-09-29 23:59:59+0000
  dt.diff("2007-01-01 01:01:01+01:00", "s")
  >>> -1167609662
  ```



  ```python
  from cytimes import Pydt

  dt = Pydt(1970, 1, 1)

  dt.is_past()
  >>> True
  dt.is_future()
  >>> False
  dt.closest("1970-01-02", "2007-01-01")
  >>> 1970-01-02 00:00:00
  dt.farthest("1970-01-02", "2007-01-01")
  >>> 2007-01-01 00:00:00
  ```



  `Pddt` extends similar functionalities to Pandas `DatetimeIndex`, making it behave more like native Python `datetime.datetime`, but for arrays of datetime values. It supports:

  - Vectorized parsing, creation, and manipulation.
  - Most of the same methods and properties as `Pydt` (see examples above), adapted for datetime-arrays.
  - Automatic handling of out-of-range datetimes in nanoseconds by downcasting to microsecond precision `'us'` to avoid overflow.



  By default, `DatetimeIndex` uses nanosecond precision `'ns'`, which cannot represent datetimes outside the range 1677-09-21 to 2262-04-11. Pddt automatically downcasts to microseconds `us` when encountering out-of-range datetimes, sacrificing nanosecond precision to allow a broader range support.

  ```python
  from cytimes import Pddt

  Pddt(["9999-01-01 00:00:00+00:00", "9999-01-02 00:00:00+00:00"])
  >>> Pddt(['9999-01-01 00:00:00+00:00', '9999-01-02 00:00:00+00:00'],
          dtype='datetime64[us, UTC]', freq=None)
  ```

  Downcasting mechanism also automacially applies to all methods that modify the datetimes, resulting values out of the `'ns'` range:

  ```python
  from cytimes import Pddt

  pt = Pddt(["1970-01-01 00:00:00+00:00", "1970-01-02 00:00:00+00:00"])


  pt.to_year(1000, "Feb", 30)
  >>> Pddt(['2970-02-28 00:00:00+00:00', '2970-02-28 00:00:00+00:00'],
          dtype='datetime64[us, UTC]', freq=None)
  ```



  cyTimes is based on several open-source repositories.

  - [babel](https://github.com/python-babel/babel)
  - [numpy](https://github.com/numpy/numpy)
  - [pandas](https://github.com/pandas-dev/pandas)

  cyTimes is built on the following open-source repositories:

  - [dateutil](https://github.com/dateutil/dateutil)

    Class <'Parser'> and <'Delta'> in this package are the cythonized version of <'dateutil.parser'> and <'dateutil.relativedelta'>. Credit and thanks go to the original authors and contributors of the `dateutil` library.


pkgId: 8f22b9980bd8f52727184b370128fcbfdafb01a014bb7854d99c2a4a621cd10f
name: python-cytosummarynet-help
arch: noarch
version: 0.0.4
epoch: 0
release: 1
summary: Development documents and examples for cytosummarynet
url: https://pypi.org/project/cytosummarynet/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cytosummarynet-0.0.4-1.src.rpm
location_href: Packages/python-cytosummarynet-help-0.0.4-1.noarch.rpm
checksum_type: sha256
description:
  A PyTorch-based deep learning library for learning an optimal way to aggregate single-cell features into population-level profiles.




  ```bash
  pip install cytosummarynet
  ```



  To try out CytoSummaryNet with sample data:

  1. Generate sample data:
  ```bash
  python examples/generate_sample_data.py
  ```

  2. Run the example pipeline:
  ```bash
  python examples/example_pipeline.py
  ```

  This will create a sample dataset and train a model using the default parameters.


pkgId: 66a59e0459f014c5d7bdc89fd0677fb7636523041cfc2c395fcd88a06e215a93
name: python-cz-changeup-help
arch: noarch
version: 1.1.1
epoch: 0
release: 1
summary: Development documents and examples for cz-changeup
url: https://pypi.org/project/cz-changeup/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cz-changeup-1.1.1-1.src.rpm
location_href: Packages/python-cz-changeup-help-1.1.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cz-changeup)](https://pypi.org/project/cz-changeup)
  [![PyPI - Version](https://img.shields.io/pypi/v/cz-changeup)](https://pypi.org/project/cz-changeup)
  [![Conda Version](https://img.shields.io/conda/vn/conda-forge/cz-changeup)](https://anaconda.org/conda-forge/cz-changeup)
  [![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)

  This plugin is a version of
  [Commitizen](https://commitizen-tools.github.io/commitizen/)'s default conventional
  style that provides more flexibility in the changelog format.



  With pip:

  ```bash
  pip install cz-changeup
  ```

  With conda:

  ```bash
  conda install -c conda-forge cz-changeup
  ```



  Add to your `pyproject.toml`:

  ```toml
  [tool.commitizen]
  name = "cz_changeup"
  ```

  The behavior of the plugin can be customized by providing the following options under `tool.commitizen`:

  | Option                          | Description                                                                                                                                      | Default |
  | ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ | ------- |
  | `changeup_repo_base_url`        | The base URL for the repository, for instance `"https://github.com/my/repo"`.                                                                    | `""`    |
  | `changeup_show_hash`            | Whether to add a link to the commit for each entry in the changelog. If `changeup_repo_base_url` is provided, the hash are linked to the commit. | `true`  |
  | `changeup_show_hash_breaking`   | Whether to add a link to the commit also for descriptions in the breaking changes section.                                                       | `true`  |
  | `changeup_show_body`            | Whether to include the commit body in the changelog.                                                                                             | `true`  |
  | `changeup_hide_breaking`        | Whether to include the breaking changes section also in the the commit body if `changeup_show_body` is true. This prevents duplicate entries.    | `true`  |
  | `changeup_body_indent`          | The number of spaces to indent the commit body if `changeup_show_body` is set to `true`.                                                         | `2`     |
  | `changeup_link_issues`          | If `true`, tries to convert issue numbers in phrases like `closes #21` to links. Only works if `changeup_repo_base_url` is provided.             | `true`  |
  | `changeup_link_external_issues` | If `true`, tries to convert external issue numbers like `user/repo/#123` to links. Currently only supports github links.                         | `true`  |
  | `changeup_scope_prefix`         | Prefix for the scope of the change.                                                                                                              | `"**"`  |
  | `changeup_scope_suffix`         | Suffix for the scope of the change.                                                                                                              | `"**"`  |
  | `changeup_scope_separator`      | Separator between the scope and the message.                                                                                                     | `": "`  |


pkgId: 574edde284b76da4a662bbfbcf661af1da4febd6740e6bd7522cfd12d0b52e95
name: python-czitools-help
arch: noarch
version: 0.7.5
epoch: 0
release: 1
summary: Development documents and examples for czitools
url: https://github.com/sebi06/czitools
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-czitools-0.7.5-1.src.rpm
location_href: Packages/python-czitools-help-0.7.5-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/czitools.svg?color=green)](https://pypi.org/project/czitools)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/czitools)](https://pypistats.org/packages/czitools)
  [![License](https://img.shields.io/pypi/l/czitools.svg?color=green)](https://github.com/sebi06/czitools/raw/master/LICENSE)
  [![codecov](https://codecov.io/github/sebi06/czitools/graph/badge.svg?token=WK1KIMZARL)](https://codecov.io/github/sebi06/czitools)
  [![Python Version](https://img.shields.io/pypi/pyversions/czitools.svg?color=green)](https://python.org)
  [![Development Status](https://img.shields.io/pypi/status/czitools.svg)](https://en.wikipedia.org/wiki/Software_release_life_cycle#Alpha)

  This repository provides a collection of tools to simplify reading CZI (Carl Zeiss Image) pixel and metadata in Python. In addition, it also contains other useful utilities to visualize CZI images inside Napari (needs to be installed). It is also available as a [Python Package on PyPi](https://pypi.org/project/czitools/)



  To install the basic functionality (will not install Napari und plotting functionality) use:

  ```text
  pip install czitools
  ```

  To install the package with all optional dependencies use:

  ```text
  pip install czitools[all]
  ```



  Please check [use_metadata_tools.py](https://github.com/sebi06/czitools/blob/main/demo/scripts/use_metadata_tools.py) for some examples.

  ```python
  from czitools.metadata_tools.czi_metadata import CziMetadata, writexml
  from czitools.metadata_tools.dimension import CziDimensions
  from czitools.metadata_tools.boundingbox import CziBoundingBox
  from czitools.metadata_tools.channel import CziChannelInfo
  from czitools.metadata_tools.scaling import CziScaling
  from czitools.metadata_tools.sample import CziSampleInfo
  from czitools.metadata_tools.objective import CziObjectives
  from czitools.metadata_tools.microscope import CziMicroscope
  from czitools.metadata_tools.add_metadata import CziAddMetaData
  from czitools.metadata_tools.detector import CziDetector
  from czitools.read_tools import read_tools
  from czitools.napari_tools import napari_tools
  import napari


  mdata = CziMetadata(filepath)


  czi_dimensions = CziDimensions(filepath)
  print("SizeS: ", czi_dimensions.SizeS)
  print("SizeT: ", czi_dimensions.SizeT)
  print("SizeZ: ", czi_dimensions.SizeZ)
  print("SizeC: ", czi_dimensions.SizeC)
  print("SizeY: ", czi_dimensions.SizeY)
  print("SizeX: ", czi_dimensions.SizeX)


  xmlfile = writexml(filepath)


  czi_channels = CziChannelInfo(filepath)


  czimd_complete = get_metadata_as_object(filepath)


  czi_scale = CziScaling(filepath)


  czi_sample = CziSampleInfo(filepath)


  czi_objectives = CziObjectives(filepath)
  czi_detectors = CziDetector(filepath)
  czi_microscope = CziMicroscope(filepath)


  czi_sample = CziSampleInfo(filepath)


  czi_addmd = CziAddMetaData(filepath)


  czi_bbox = CziBoundingBox(filepath)
  ```



  While the [pylibCZIrw](https://pypi.org/project/pylibCZIrw/) is focussing on reading individual planes it is also helpful to read CZI pixel data as a STCZYX(A) stack. Please check [use_read_tools.py](https://github.com/sebi06/czitools/blob/main/demo/scripts/use_read_tools.py) for some examples.

  ```python

  array6d, mdata = read_tools.read_6darray(filepath,
                                           use_dask=True,
                                           chunk_zyx=False,
                                           
                                           
                                           
                                           
                                          )

  if array6d is None:
      print("Empty array6d. Nothing to display in Napari")
  else:

      
      viewer = napari.Viewer()
      layers = napari_tools.show(viewer, array6d, mdata,
                                 blending="additive",
                                 contrast='from_czi',
                                 gamma=0.85,
                                 show_metadata="tree",
                                 name_sliders=True)

      napari.run()
  ```

  ![5D CZI inside Napari](https://github.com/sebi06/czitools/raw/main/images/czi_napari1.png)





  The basic usage can be inferred from this sample notebook:&nbsp;
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/sebi06/czitools/blob/main/demo/notebooks/read_czi_metadata.ipynb)



  The basic usage can be inferred from this sample notebook:&nbsp;
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/sebi06/czitools/blob/main/demo/notebooks/read_czi_pixeldata.ipynb)



  The basic usage can be inferred from this sample notebook:&nbsp;
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/sebi06/czitools/blob/main/demo/notebooks/omezarr_from_czi_5d.ipynb)




  The basic usage can be inferred from this sample notebook:&nbsp;
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/sebi06/czitools/blob/main/demo/notebooks/save_with_ZSTD_compression.ipynb)



  The basic usage can be inferred from this sample notebook:&nbsp;
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/sebi06/czitools/blob/main/demo/notebooks/show_czi_surface.ipynb)



  The basic usage can be inferred from this sample notebook:&nbsp;
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/sebi06/czitools/blob/main/demo/notebooks/read_czi_segment_voroni_otsu.ipynb)



  The code to read multi-dimensional with delayed reading using Dask array was heavily inspired by input from: [Pradeep Rajasekhar](https://github.com/pr4deepr).

  Local installation (base functionality only):

  ```text
  pip install -e .
  ```



  Local installation (full functionality):

  ```text
  pip install -e ".[all]"
  ```


pkgId: b7195850aabebffb93c8a70d0afa77f7a91e9ee8ac5ce36b9d96c53a38059366
name: python-czlai-help
arch: noarch
version: 0.1.0a6
epoch: 0
release: 1
summary: Development documents and examples for czlai
url: https://github.com/CZL-AI/czlai-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-czlai-0.1.0a6-1.src.rpm
location_href: Packages/python-czlai-help-0.1.0a6-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/czlai.svg)](https://pypi.org/project/czlai/)

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


  The REST API documentation can be found on [docs.gjpet.com](https://docs.gjpet.com). The full API of this library can be found in [api.md](https://github.com/CZL-AI/czlai-python/tree/main/api.md).



  ```sh

  pip install --pre czlai
  ```



  The full API of this library can be found in [api.md](https://github.com/CZL-AI/czlai-python/tree/main/api.md).

  ```python
  from czlai import Czlai

  client = Czlai()

  response = client.ai_checkup.session_start()
  print(response.data)
  ```

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



  Simply import `AsyncCzlai` instead of `Czlai` and use `await` with each API call:

  ```python
  import asyncio
  from czlai import AsyncCzlai

  client = AsyncCzlai()


  async def main() -> None:
      response = await client.ai_checkup.session_start()
      print(response.data)


  asyncio.run(main())
  ```

  Functionality between the synchronous and asynchronous clients is otherwise identical.



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

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

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



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

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

  All errors inherit from `czlai.APIError`.

  ```python
  import czlai
  from czlai import Czlai

  client = Czlai()

  try:
      client.ai_checkup.session_start()
  except czlai.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except czlai.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except czlai.APIStatusError as e:
      print("Another non-200-range status code was received")
      print(e.status_code)
      print(e.response)
  ```

  Error codes are as followed:

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



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

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

  ```python
  from czlai import Czlai


  client = Czlai(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).ai_checkup.session_start()
  ```



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

  ```python
  from czlai import Czlai


  client = Czlai(
      
      timeout=20.0,
  )


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


  client.with_options(timeout=5.0).ai_checkup.session_start()
  ```

  On timeout, an `APITimeoutError` is thrown.

  Note that requests that time out are [retried twice by default](https://github.com/CZL-AI/czlai-python/tree/main/#retries).





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

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

  ```shell
  $ export CZLAI_LOG=info
  ```

  Or to `debug` for more verbose logging.



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

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



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

  ```py
  from czlai import Czlai

  client = Czlai()
  response = client.ai_checkup.with_raw_response.session_start()
  print(response.headers.get('X-My-Header'))

  ai_checkup = response.parse()  # get the object that `ai_checkup.session_start()` would have returned
  print(ai_checkup.data)
  ```

  These methods return an [`APIResponse`](https://github.com/CZL-AI/czlai-python/tree/main/src/czlai/_response.py) object.

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



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

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

  ```python
  with client.ai_checkup.with_streaming_response.session_start() as response:
      print(response.headers.get("X-My-Header"))

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

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



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

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



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

  ```py
  import httpx

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

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



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



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



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

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

  ```python
  from czlai import Czlai, DefaultHttpxClient

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

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

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



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



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

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

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

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



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

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

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



  Python 3.8 or higher.



  See [the contributing documentation](https://github.com/CZL-AI/czlai-python/tree/main/./CONTRIBUTING.md).


pkgId: a966314ebe16df4f85c41c2e6d8682313bf4059f065d779f29f2115dc505389c
name: python-czml3-help
arch: noarch
version: 2.1.0
epoch: 0
release: 1
summary: Development documents and examples for czml3
url: https://github.com/Stoops-ML/czml3
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-czml3-2.1.0-1.src.rpm
location_href: Packages/python-czml3-help-2.1.0-1.noarch.rpm
checksum_type: sha256
description:
  ![pypi](https://img.shields.io/pypi/v/czml3)
  ![conda](https://img.shields.io/conda/vn/conda-forge/czml3?label=conda)
  ![Python](https://img.shields.io/pypi/pyversions/czml3)
  [![codecov](https://codecov.io/gh/Stoops-ML/czml3/graph/badge.svg?token=EF8SIL2JBV)](https://codecov.io/gh/Stoops-ML/czml3)
  ![pypi-downloads](https://img.shields.io/pepy/dt/czml3?label=pypi%20downloads)
  ![conda-downloads](https://img.shields.io/conda/dn/conda-forge/czml3?label=conda%20downloads)
  ![workflow-status](https://img.shields.io/github/actions/workflow/status/Stoops-ML/czml3/workflow.yml?branch=main)
  ![license](https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square)

  From the official [CZML Guide](https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/CZML-Guide):
  > CZML is a JSON format for describing a time-dynamic graphical scene, primarily for display in a web browser running Cesium. It describes lines, points, billboards, models, and other graphical primitives, and specifies how they change with time.

  czml3 aims to make the process of writing CZML files in Python easy by:
  - Type checking properties
  - Conversion of properties to their expected format


  You can install czml3 using pip:
  ```
  pip install czml3
  ```

  or conda:
  ```
  conda install czml3 --channel conda-forge
  ```


  A CZML document is a list of *packets*, which have several properties. Recreating the blue box from Cesium sandcastle's [CZML Box](https://sandcastle.cesium.com/?src=CZML%20Box.html&label=CZML):

  ```
  from czml3 import Document, Packet, Preamble
  from czml3.properties import (
      Box,
      BoxDimensions,
      Cartesian3Value,
      Color,
      Material,
      Position,
      SolidColorMaterial,
  )
  packet_box = Packet(
      position=Position(cartographicDegrees=[-114.0, 40.0, 300000.0]),
      box=Box(
          dimensions=BoxDimensions(
              cartesian=Cartesian3Value(values=[400000.0, 300000.0, 500000.0])
          ),
          material=Material(
              solidColor=SolidColorMaterial(color=Color(rgba=[0, 0, 255, 255]))
          ),
      ),
  )
  doc = Document(packets=[Preamble(name="box"), packet_box])
  print(doc)
  ```
  ```
  [
      {
          "id": "document",
          "version": "1.0",
          "name": "box"
      },
      {
          "id": "b9f211b1-6e9d-45b2-b484-516d127ffa22",
          "position": {
              "cartographicDegrees": [
                  -114.0,
                  40.0,
                  300000.0
              ]
          },
          "box": {
              "dimensions": {
                  "cartesian": [
                      400000.0,
                      300000.0,
                      500000.0
                  ]
              },
              "material": {
                  "solidColor": {
                      "color": {
                          "rgba": [
                              0.0,
                              0.0,
                              255.0,
                              255.0
                          ]
                      }
                  }
              }
          }
      }
  ]
  ```

  czml3 uses [pydantic](https://docs.pydantic.dev/latest/) for all classes. As such czml3 automatically converts some properties to their appropriate type. For example, the following creates a Position property of doubles using a numpy array of interger type:
  ```
  import numpy as np
  from czml3.properties import Position
  print(Position(cartographicDegrees=np.array([-114, 40, 300000], dtype=int)))
  ```
  ```
  {
      "cartographicDegrees": [
          -114.0,
          40.0,
          300000.0
      ]
  }
  ```


  You can easily display your CZML document using our interactive widget:
  ```
  from czml3.examples import simple
  from czml3.widget import CZMLWidget
  CZMLWidget(simple)
  ```
  ![Widget](https://raw.githubusercontent.com/poliastro/czml3/master/widget-screenshot.png)


  You want to contribute? Awesome! There are lots of [CZML properties](https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/Packet) that we still did not implement. All ideas welcome!


pkgId: 5c6196116ce3b7e304d14e731c4c5fb5ca7e4d37aa69525707a14997c4b8942d
name: python-czml3-help
arch: noarch
version: 2.2.0
epoch: 0
release: 1
summary: Development documents and examples for czml3
url: https://github.com/Stoops-ML/czml3
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-czml3-2.2.0-1.src.rpm
location_href: Packages/python-czml3-help-2.2.0-1.noarch.rpm
checksum_type: sha256
description:
  ![pypi](https://img.shields.io/pypi/v/czml3)
  ![conda](https://img.shields.io/conda/vn/conda-forge/czml3?label=conda)
  ![Python](https://img.shields.io/pypi/pyversions/czml3)
  [![codecov](https://codecov.io/gh/Stoops-ML/czml3/graph/badge.svg?token=EF8SIL2JBV)](https://codecov.io/gh/Stoops-ML/czml3)
  ![pypi-downloads](https://img.shields.io/pepy/dt/czml3?label=pypi%20downloads)
  ![conda-downloads](https://img.shields.io/conda/dn/conda-forge/czml3?label=conda%20downloads)
  ![workflow-status](https://img.shields.io/github/actions/workflow/status/Stoops-ML/czml3/workflow.yml)
  ![license](https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square)

  From the official [CZML Guide](https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/CZML-Guide):
  > CZML is a JSON format for describing a time-dynamic graphical scene, primarily for display in a web browser running Cesium. It describes lines, points, billboards, models, and other graphical primitives, and specifies how they change with time.

  czml3 aims to make the process of writing CZML files in Python easy by:
  - Type checking properties
  - Cooercion of data to their required format
  - Creating minimal CZML files that only contains fields with information


  You can install czml3 using pip:
  ```
  pip install czml3
  ```

  or conda:
  ```
  conda install czml3 --channel conda-forge
  ```


  A CZML document is a list of *packets*, which have several properties. Recreating the blue box from Cesium sandcastle's [CZML Box](https://sandcastle.cesium.com/?src=CZML%20Box.html&label=CZML):

  ```
  from czml3 import CZML_VERSION, Document, Packet
  from czml3.properties import (
      Box,
      BoxDimensions,
      Color,
      Material,
      Position,
      SolidColorMaterial,
  )
  from czml3.types import Cartesian3Value
  packet_box = Packet(
      id="my_id",  # fixing id here to ensure test passes
      position=Position(cartographicDegrees=[-114.0, 40.0, 300000.0]),
      box=Box(
          dimensions=BoxDimensions(
              cartesian=Cartesian3Value(values=[400000.0, 300000.0, 500000.0])
          ),
          material=Material(
              solidColor=SolidColorMaterial(color=Color(rgba=[0, 0, 255, 255]))
          ),
      ),
  )
  doc = Document(
      packets=[Packet(id="document", name="box", version=CZML_VERSION), packet_box]
  )
  print(doc)
  ```
  ```
  [
      {
          "id": "document",
          "name": "box",
          "version": "1.0"
      },
      {
          "id": "my_id",
          "position": {
              "cartographicDegrees": [
                  -114.0,
                  40.0,
                  300000.0
              ]
          },
          "box": {
              "dimensions": {
                  "cartesian": [
                      400000.0,
                      300000.0,
                      500000.0
                  ]
              },
              "material": {
                  "solidColor": {
                      "color": {
                          "rgba": [
                              0.0,
                              0.0,
                              255.0,
                              255.0
                          ]
                      }
                  }
              }
          }
      }
  ]
  ```

  czml3 uses [pydantic](https://docs.pydantic.dev/latest/) for all classes. As such czml3 is able to [coerce data to their right type](https://docs.pydantic.dev/latest/why/#json-schema). For example, the following creates a Position property of doubles using a numpy array of interger type:
  ```
  import numpy as np
  from czml3.properties import Position
  print(Position(cartographicDegrees=np.array([-114, 40, 300000], dtype=int)))
  ```
  ```
  {
      "cartographicDegrees": [
          -114.0,
          40.0,
          300000.0
      ]
  }
  ```


  You want to contribute? Awesome! There are lots of [CZML properties](https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/Packet) and validations that we still did not implement, which can be found [here](MissingProperties.md).

  All ideas welcome!


pkgId: bd9a05687a622d16c444e4560d11b82f5603ac1ea3518134e146a3371ae21944
name: python-dabl-help
arch: noarch
version: 0.3.2
epoch: 0
release: 1
summary: Development documents and examples for dabl
url: https://pypi.org/project/dabl/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dabl-0.3.2-1.src.rpm
location_href: Packages/python-dabl-help-0.3.2-1.noarch.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/dabl/dabl/actions/workflows/ci.yml/badge.svg)](https://github.com/dabl/dabl/actions/workflows/ci.yml)

  The data analysis baseline library.

  - "Mr Sanchez, are you a data scientist?"
  - "I dabl, Mr president."

  Find more information on the [website](https://dabl.github.io/).



  ```
  pip install dabl
  ```

  or [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/dabl/dabl/main)


  This library is very much still under development. Current code focuses mostly on exploratory visualization and preprocessing.
  There are also drop-in replacements for GridSearchCV and RandomizedSearchCV using successive halfing.
  There are preliminary portfolios in the style of
  [POSH
  auto-sklearn](https://ml.informatik.uni-freiburg.de/papers/18-AUTOML-AutoChallenge.pdf)
  to find strong models quickly.  In essence that boils down to a quick search
  over different gradient boosting models and other tree ensembles and
  potentially kernel methods.

  Check out the [the website](https://dabl.github.io/dev/) and [example gallery](https://dabl.github.io/0.1.9/auto_examples/index.html) to get an idea of the visualizations that are available.

  Stay Tuned!




  [Lux](https://github.com/lux-org/lux) is an awesome project for easy interactive visualization of pandas dataframes within notebooks.


  [Pandas Profiling](https://github.com/pandas-profiling/pandas-profiling) can
  provide a thorough summary of the data in only a single line of code. Using the
  ```ProfileReport()``` method, you are able to access a HTML report of your data
  that can help you find correlations and identify missing data.

  `dabl` focuses less on statistical measures of individual columns, and more on
  providing a quick overview via visualizations, as well as convienient
  preprocessing and model search for machine learning.

rpm_license:
  Copyright (c) 2016, Vighnesh Birodkar All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  * Neither the name of project-template 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: 040100ee0271b3e4542f438967efb7afd17d1b985024f12b5b844ef1fc784a5e
name: python-dafne-help
arch: noarch
version: 1.9a0
epoch: 0
release: 1
summary: Development documents and examples for dafne
url: https://github.com/dafne-imaging/dafne
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dafne-1.9a0-1.src.rpm
location_href: Packages/python-dafne-help-1.9a0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/dafne.svg)](https://badge.fury.io/py/dafne)
  [![PDF Documentation](https://img.shields.io/badge/Docs-pdf-brightgreen)](https://www.dafne.network/files/documentation.pdf)
  [![HTML Documentation](https://img.shields.io/badge/Docs-html-brightgreen)](https://www.dafne.network/documentation/)


  Deep Anatomical Federated Network is a program for the segmentation of medical images. It relies on a server to provide deep learning models to aid the segmentation, and incremental learning is used to improve the performance. See https://www.dafne.network/ for documentation and user information.


  Please install the Visual Studio Redistributable Package under windows: https://aka.ms/vs/16/release/vc_redist.x64.exe
  Then, run the provided installer


  Install the Dafne App from the downloaded .dmg file as usual. Make sure to download the archive appropriate for your architecture (x86 or arm).


  The Linux distribution is a self-contained executable file. Simply download it, make it executable, and run it.


  Dafne can also be installed with pip
  `pip install dafne`


  If you are writing a scientific paper, and you used Dafne for your data evaluation, please cite the following paper:

  > Santini F, Wasserthal J, Agosti A, et al. *Deep Anatomical Federated Network (Dafne): an open client/server framework for the continuous collaborative improvement of deep-learning-based medical image segmentation*. 2023 doi: [10.48550/arXiv.2302.06352](https://doi.org/10.48550/arXiv.2302.06352).






  Run:
  `python dafne.py <path_to_dicom_img>`





  The input of the apply function is:
  ```
  dict({
      'image': np.array (2D image)
      'resolution': sequence with two elements (image resolution in mm)
      'split_laterality': True/False (indicates whether the ROIs should be split in L/R if applicable)
      'classification': str - The classification tag of the image (optional, to identify model variants)
  })
  ```

  The output of the classifier is a string.
  The output of the segmenters is:
  ```
  dict({
      roi_name_1: np.array (2D mask),
      roi_name_2: ...
  })
  ```


  The input of the incremental learn functions are:
  ```
  training data: dict({
      'resolution': sequence (see above)
      'classification': str (see above)
      'image_list': list([
          - np.array (2D image)
          - np.array (2D image)
          - ...
      ])
  })

  training outputs: list([
      - dict({
          roi_name_1: np.array (2D mask)
          roi_name_2: ...
      })
      - dict...
  ```

  Every entry in the training outputs list corresponds to an entry in the image_list inside the training data.
  So `len(training_data['image_list']) == len(training_outputs)`.


  Input/Output is based on [DOSMA](https://github.com/ad12/DOSMA) - GPLv3 license

  This software includes the [Segment Anything Model (SAM)](https://github.com/facebookresearch/segment-anything) - Apache 2.0 license

  Other packages required for this project are listed in requirements.txt


pkgId: 24a0163f33b35b9a8f1be56be85356b9f9ae9fad0119d2051ad56d746e0ccb01
name: python-dagshub-help
arch: noarch
version: 0.4.0
epoch: 0
release: 1
summary: Development documents and examples for dagshub
url: https://github.com/DagsHub/client
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dagshub-0.4.0-1.src.rpm
location_href: Packages/python-dagshub-help-0.4.0-1.noarch.rpm
checksum_type: sha256
description:
  To improve your experience, we collect analytics on client usage. If you want to disable analytics collection,
  set the `DAGSHUB_DISABLE_ANALYTICS` environment variable to any value.
  Made with 🐶 by [DagsHub](https://dagshub.com/).


pkgId: bc98024a850e8d3169289a8d85888c674ab7016c1da122bf0c34bee72998f429
name: python-dagster-cloud-help
arch: noarch
version: 1.9.6
epoch: 0
release: 1
summary: Development documents and examples for dagster-cloud
url: https://dagster.io/cloud
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dagster-cloud-1.9.6-1.src.rpm
location_href: Packages/python-dagster-cloud-help-1.9.6-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <a target="_blank" href="https://dagster.io/cloud" style="background:none">
      <img src="https://github.com/dagster-io/dagster-cloud/raw/main/assets/dagster-cloud-logo.png" width="auto"/>
    </a>
    <br /><br />
    <a target="_blank" href="https://twitter.com/dagster" style="background:none">
      <img src="https://img.shields.io/badge/twitter-dagster-blue.svg?labelColor=4F43DD&color=163B36&logo=twitter" />
    </a>
    <a target="_blank" href="https://dagster.io/slack" style="background:none">
      <img src="https://img.shields.io/badge/slack-dagster-blue.svg?labelColor=4F43DD&color=163B36&logo=slack" />
    </a>
    <a target="_blank" href="https://linkedin.com/showcase/dagster" style="background:none">
      <img src="https://img.shields.io/badge/linkedin-dagster-blue.svg?labelColor=4F43DD&color=163B36&logo=linkedin" />
    </a>
    <a target="_blank" href="https://github.com/dagster-io/dagster" style="background:none">
      <img src="https://img.shields.io/github/stars/dagster-io/dagster?labelColor=4F43DD&color=163B36&logo=github">
    </a>
    <br />
    <a target="_blank" href="https://pypi.org/project/dagster-cloud/" style="background:none">
      <img src="https://img.shields.io/pypi/v/dagster-cloud?labelColor=4F43DD&color=163B36">
    </a>
    <a target="_blank" href="https://pypi.org/project/dagster-cloud/" style="background:none">
      <img src="https://img.shields.io/pypi/pyversions/dagster-cloud?labelColor=4F43DD&color=163B36">
    </a>
  </p>



  The enterprise orchestration platform that puts developer experience first, with fully serverless or hybrid deployments, native branching, and out-of-the-box CI/CD.



  The complete Dagster Cloud feature set can be found on our [website](https://dagster.io/cloud). You
  can [sign up for Dagster Cloud](https://dagster.cloud/signup) and get started with a free 30 day
  trial.



  The Dagster Cloud Agent is available on PyPI and officially supports Python 3.8.

  ```
  pip install dagster-cloud
  ```



  You can find the full Dagster Cloud documentation on our
  [website](https://docs.dagster.io/dagster-cloud).



  Connect with thousands of other data practitioners building with Dagster. Share knowledge, get help,
  and contribute to the open-source project. To see featured material and upcoming events, check out
  our [Dagster Community](https://dagster.io/community) page.

  Join our community here:

  - 🌟 [Star us on Github](https://github.com/dagster-io/dagster)
  - 📥 [Subscribe to our Newsletter](https://dagster.io/newsletter-signup)
  - 🐦 [Follow us on Twitter](https://twitter.com/dagster)
  - 🕴️ [Follow us on LinkedIn](https://linkedin.com/showcase/dagster)
  - 📺 [Subscribe to our YouTube channel](https://www.youtube.com/channel/UCfLnv9X8jyHTe6gJ4hVBo9Q)
  - 📚 [Read our blog posts](https://dagster.io/blog)
  - 👋 [Join us on Slack](https://dagster.io/slack)
  - 🗃 [Browse Slack archives](https://discuss.dagster.io)
  - ✏️ [Start a Github Discussion](https://github.com/dagster-io/dagster/discussions)


pkgId: c10f62930da8f7e132381c73890731773401fce180ed783192d39e6edbfc0329
name: python-dagster-components-help
arch: noarch
version: 0.1.5
epoch: 0
release: 1
summary: Development documents and examples for dagster-components
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dagster-components-0.1.5-1.src.rpm
location_href: Packages/python-dagster-components-help-0.1.5-1.noarch.rpm
checksum_type: sha256
url:
  https://github.com/dagster-io/dagster/tree/master/examples/experimental/dagster-components/dagster-components


pkgId: fa0ad25ec0909f879db973852d860e42d8362587109141bedfcd0ecc6572c100
name: python-dagster-help
arch: noarch
version: 1.9.6
epoch: 0
release: 1
summary: Development documents and examples for dagster
url: https://dagster.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dagster-1.9.6-1.src.rpm
location_href: Packages/python-dagster-help-1.9.6-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
    <!-- Note: Do not try adding the dark mode version here with the `picture` element, it will break formatting in PyPI -->
    <a target="_blank" href="https://dagster.io" style="background:none">
      <img alt="dagster logo" src="https://raw.githubusercontent.com/dagster-io/dagster/master/.github/dagster-readme-header.svg" width="auto" height="100%">
    </a>
    <a target="_blank" href="https://github.com/dagster-io/dagster" style="background:none">
      <img src="https://img.shields.io/github/stars/dagster-io/dagster?labelColor=4F43DD&color=163B36&logo=github">
    </a>
    <a target="_blank" href="https://github.com/dagster-io/dagster/blob/master/LICENSE" style="background:none">
      <img src="https://img.shields.io/badge/License-Apache_2.0-blue.svg?label=license&labelColor=4F43DD&color=163B36">
    </a>
    <a target="_blank" href="https://pypi.org/project/dagster/" style="background:none">
      <img src="https://img.shields.io/pypi/v/dagster?labelColor=4F43DD&color=163B36">
    </a>
    <a target="_blank" href="https://pypi.org/project/dagster/" style="background:none">
      <img src="https://img.shields.io/pypi/pyversions/dagster?labelColor=4F43DD&color=163B36">
    </a>
    <a target="_blank" href="https://twitter.com/dagster" style="background:none">
      <img src="https://img.shields.io/badge/twitter-dagster-blue.svg?labelColor=4F43DD&color=163B36&logo=twitter" />
    </a>
    <a target="_blank" href="https://dagster.io/slack" style="background:none">
      <img src="https://img.shields.io/badge/slack-dagster-blue.svg?labelColor=4F43DD&color=163B36&logo=slack" />
    </a>
    <a target="_blank" href="https://linkedin.com/showcase/dagster" style="background:none">
      <img src="https://img.shields.io/badge/linkedin-dagster-blue.svg?labelColor=4F43DD&color=163B36&logo=linkedin" />
    </a>
  </div>

  **Dagster is a cloud-native data pipeline orchestrator for the whole development lifecycle, with integrated lineage and observability, a declarative programming model, and best-in-class testability.**

  It is designed for **developing and maintaining data assets**, such as tables, data sets, machine learning models, and reports.

  With Dagster, you declare—as Python functions—the data assets that you want to build. Dagster then helps you run your functions at the right time and keep your assets up-to-date.

  Here is an example of a graph of three assets defined in Python:

  ```python
  from dagster import asset
  from pandas import DataFrame, read_html, get_dummies
  from sklearn.linear_model import LinearRegression

  @asset
  def country_populations() -> DataFrame:
      df = read_html("https://tinyurl.com/mry64ebh")[0]
      df.columns = ["country", "pop2022", "pop2023", "change", "continent", "region"]
      df["change"] = df["change"].str.rstrip("%").str.replace("−", "-").astype("float")
      return df

  @asset
  def continent_change_model(country_populations: DataFrame) -> LinearRegression:
      data = country_populations.dropna(subset=["change"])
      return LinearRegression().fit(get_dummies(data[["continent"]]), data["change"])

  @asset
  def continent_stats(country_populations: DataFrame, continent_change_model: LinearRegression) -> DataFrame:
      result = country_populations.groupby("continent").sum()
      result["pop_change_factor"] = continent_change_model.coef_
      return result
  ```

  The graph loaded into Dagster's web UI:

  <p align="center">
    <img width="100%" alt="An example asset graph as rendered in the Dagster UI" src="https://raw.githubusercontent.com/dagster-io/dagster/master/.github/example-lineage.png">
  </p>

  Dagster is built to be used at every stage of the data development lifecycle - local development, unit tests, integration tests, staging environments, all the way up to production.



  If you're new to Dagster, we recommend reading about its [core concepts](https://docs.dagster.io/concepts) or learning with the hands-on [tutorial](https://docs.dagster.io/tutorial).

  Dagster is available on PyPI and officially supports Python 3.9 through Python 3.12.

  ```bash
  pip install dagster dagster-webserver
  ```

  This installs two packages:

  - `dagster`: The core programming model.
  - `dagster-webserver`: The server that hosts Dagster's web UI for developing and operating Dagster jobs and assets.

  Running on a Mac with an Apple silicon chip? Check the [install details here](https://docs.dagster.io/getting-started/install#installing-dagster-into-an-existing-python-environment).



  You can find the full Dagster documentation [here](https://docs.dagster.io), including the ['getting started' guide](https://docs.dagster.io/getting-started).

  <hr/>



    <p align="center">
      <img width="100%" alt="image" src="https://raw.githubusercontent.com/dagster-io/dagster/master/.github/key-features-cards.svg">
    </p>



  Identify the key assets you need to create using a declarative approach, or you can focus on running basic tasks. Embrace CI/CD best practices from the get-go: build reusable components, spot data quality issues, and flag bugs early.



  Put your pipelines into production with a robust multi-tenant, multi-tool engine that scales technically and organizationally.



  Maintain control over your data as the complexity scales. Centralize your metadata in one tool with built-in observability, diagnostics, cataloging, and lineage. Spot any issues and identify performance improvement opportunities.

  <hr />



  Dagster provides a growing library of integrations for today’s most popular data tools. Integrate with the tools you already use, and deploy to your infrastructure.

  <br/>
  <p align="center">
      <a target="_blank" href="https://dagster.io/integrations" style="background:none">
          <img width="100%" alt="image" src="https://raw.githubusercontent.com/dagster-io/dagster/master/.github/integrations-bar-for-readme.png">
      </a>
  </p>



  Connect with thousands of other data practitioners building with Dagster. Share knowledge, get help,
  and contribute to the open-source project. To see featured material and upcoming events, check out
  our [Dagster Community](https://dagster.io/community) page.

  Join our community here:

  - 🌟 [Star us on GitHub](https://github.com/dagster-io/dagster)
  - 📥 [Subscribe to our Newsletter](https://dagster.io/newsletter-signup)
  - 🐦 [Follow us on Twitter](https://twitter.com/dagster)
  - 🕴️ [Follow us on LinkedIn](https://linkedin.com/showcase/dagster)
  - 📺 [Subscribe to our YouTube channel](https://www.youtube.com/@dagsterio)
  - 📚 [Read our blog posts](https://dagster.io/blog)
  - 👋 [Join us on Slack](https://dagster.io/slack)
  - 🗃 [Browse Slack archives](https://discuss.dagster.io)
  - ✏️ [Start a GitHub Discussion](https://github.com/dagster-io/dagster/discussions)



  For details on contributing or running the project for development, check out our [contributing
  guide](https://docs.dagster.io/community/contributing/).



  Dagster is [Apache 2.0 licensed](https://github.com/dagster-io/dagster/blob/master/LICENSE).


pkgId: e2f22f473136d8b2c4f4b21c8ea7872f03a49043dad11582fb3084d51803cc0f
name: python-dagster-mssql-bcp-help
arch: noarch
version: 0.0.12
epoch: 0
release: 1
summary: Development documents and examples for dagster-mssql-bcp
url: https://github.com/cody-scott/dagster-mssql-bcp
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dagster-mssql-bcp-0.0.12-1.src.rpm
location_href: Packages/python-dagster-mssql-bcp-help-0.0.12-1.noarch.rpm
checksum_type: sha256
description:
  ![Unit tests](https://github.com/cody-scott/dagster-mssql-bcp/actions/workflows/python-test.yml/badge.svg)


  ODBC is slow 🐢 bcp is fast! 🐰

  This is a custom dagster IO manager for loading data into SQL Server using the `bcp` utility.





  ![PyPI](https://img.shields.io/pypi/v/dagster-mssql-bcp?label=latest%20stable&logo=pypi)

  `pip install dagster-mssql-bcp`



  The `bcp` utility must be installed on the machine that is running the dagster pipeline.

  See [Microsoft's documentation](https://learn.microsoft.com/en-us/sql/tools/bcp-utility?view=sql-server-ver16&tabs=windows) for more information.

  Ideally you should place this on your `PATH`, but you can specify in the IO configuration where it is located.



  You need the ODBC drivers installed on the machine that is running the dagster pipeline.

  See [Microsoft's documentation](https://learn.microsoft.com/en-us/sql/connect/odbc/download-odbc-driver-for-sql-server?view=sql-server-ver16) for more information.



  The user running the dagster pipeline must have the necessary permissions to load data into the SQL Server database.

  * `CREATE SCHEMA`
  * `CREATE/ALTER TABLES`





  Polars processes as a `LazyFrame`. Either a `DataFrame` or `LazyFrame` can be provided as an output of your asset before its cast automatically to `lazy`

  ```python
  from dagster import asset, Definitions
  from dagster_mssql_bcp import PolarsBCPIOManager
  import polars as pl

  io_manager = PolarsBCPIOManager(
      host="my_mssql_server",
      database="my_database",
      user="username",
      password="password",
      query_props={
          "TrustServerCertificate": "yes",
      },
      bcp_arguments={"-u": ""},
      bcp_path="/opt/mssql-tools18/bin/bcp",
  )

  @asset(
      metadata={
          "asset_schema": [
              {"name": "id", "type": "INT"},
          ],
          "schema": "my_schema",
      }
  )
  def my_polars_asset(context):
      return pl.DataFrame({"id": [1, 2, 3]})


  @asset(
      metadata={
          "asset_schema": [
              {"name": "id", "type": "INT"},
          ],
          "schema": "my_schema",
      }
  )
  def my_polars_asset_lazy(context):
      return pl.LazyFrame({"id": [1, 2, 3]})

  defs = Definitions(
      assets=[my_polars_asset, my_polars_asset_lazy],
      io_managers={
          "io_manager": io_manager,
      },
  )

  ```



  ```python
  from dagster import asset, Definitions
  from dagster_mssql_bcp import PandasBCPIOManager
  import pandas as pd

  io_manager = PandasBCPIOManager(
      host="my_mssql_server",
      database="my_database",
      user="username",
      password="password",
      query_props={
          "TrustServerCertificate": "yes",
      },
      bcp_arguments={"-u": ""},
      bcp_path="/opt/mssql-tools18/bin/bcp",
  )

  @asset(
      metadata={
          "asset_schema": [
              {"name": "id", "type": "INT"},
          ],
          "schema": "my_schema",
      }
  )
  def my_pandas_asset(context):
      return pd.DataFrame({"id": [1, 2, 3]})


  defs = Definitions(
      assets=[my_pandas_asset],
      io_managers={
          "io_manager": io_manager,
      },
  )

  ```

  The `asset schema` defines your table structure and your asset returns your data to load.



  For more details see [assets doc](https://github.com/cody-scott/dagster-mssql-bcp/blob/main/docs/assets.md), [io manager doc](https://github.com/cody-scott/dagster-mssql-bcp/blob/main/docs/io_manager.md), and for how its implemented, the [dev doc](https://github.com/cody-scott/dagster-mssql-bcp/blob/main/docs/dev.md).

rpm_license:
  MIT License  Copyright (c) 2024 Cody Scott  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: de93cc1c06964de7d67238dca79a2101b5b4ef22249d05fbbf8d5433f54c08a5
name: python-dagster-pandas-help
arch: noarch
version: 0.25.6
epoch: 0
release: 1
summary: Development documents and examples for dagster-pandas
url: https://github.com/dagster-io/dagster
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dagster-pandas-0.25.6-1.src.rpm
location_href: Packages/python-dagster-pandas-help-0.25.6-1.noarch.rpm
checksum_type: sha256
description:
  The docs for `dagster-pandas` can be found
  [here](https://docs.dagster.io/_apidocs/libraries/dagster-pandas).


pkgId: 71202377d558f9f5c746f1d1e5f2f7bc870d9c460004bee50b8ef5b4c6eb7148
name: python-dailalib-help
arch: noarch
version: 3.15.1
epoch: 0
release: 1
summary: Development documents and examples for dailalib
url: https://github.com/mahaloz/DAILA
rpm_license: BSD 2 Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dailalib-3.15.1-1.src.rpm
location_href: Packages/python-dailalib-help-3.15.1-1.noarch.rpm
checksum_type: sha256
description:
  The Decompiler Artificial Intelligence Language Assistant (DAILA) is a unified interface for AI systems to be used in decompilers.
  Using DAILA, you can utilize various AI systems, like local and remote LLMs, all in the same scripting and GUI interfaces across many decompilers.
  DAILA was featured in the keynote talk at [HITCON CMT 2023](https://youtu.be/HbrebQiFLDs?si=TJhKSju85jTLSsiT).

  ![](./assets/ida_daila.png)

  **Join our discord below for more online help** (hosted on the BinSync server):

  [![Discord](https://img.shields.io/discord/900841083532087347?label=Discord&style=plastic)](https://discord.gg/wZSCeXnEvR)



  DAILA interacts with the decompiler abstractly through the [LibBS](https://github.com/binsync/libbs) library.
  This allows DAILA to support the following decompilers:
  - IDA Pro: **>= 8.4**
  - Ghidra: **>= 11.1**
  - Binary Ninja: **>= 2.4**
  - angr-management: **>= 9.0**

  DAILA supports any LLM supported in [LiteLLM](https://github.com/BerriAI/litellm), such as:
  - ChatGPT
  - Claude
  - Llama2
  - Gemini
  - and more...

  DAILA also supports local models of different types, like [VarBERT](https://github.com/binsync/varbert_api), a local model for renaming variables in decompilation published in S&P 2024.


  Install our library backend through pip and our decompiler plugin through our installer:
  ```bash
  pip3 install dailalib && daila --install
  ```

  This is the light mode. **If you want to use VarBERT, you must install the full version**:
  ```bash
  pip3 install 'dailalib[full]' && daila --install
  ```

  This will also download the VarBERT models for you through the [VarBERT API](https://github.com/binsync/varbert_api).
  If you happen to be installing DAILA on a machine that won't have internet access, like a secure network, you can use our Docker image in the [Docker Container](#docker-container) section.


  You need to do a few extra steps to get Ghidra working.
  Next, enable the DAILA plugin:
  1. Start Ghidra and open a binary
  2. Goto the `Windows > Script Manager` menu
  3. Search for `daila` and enable the script

  You must have `python3` in your path for the Ghidra version to work. We quite literally call it from inside Python 2.
  You may also need to enable the `$USER_HOME/ghidra_scripts` as a valid scripts path in Ghidra.


  If the above fails, you will need to manually install.
  To manually install, first `pip3 install dailalib` on the repo, then copy the [daila_plugin.py](./dailalib/daila_plugin.py) file to your decompiler's plugin directory.



  DAILA is designed to be used in two ways:
  1. As a decompiler plugin with a GUI
  2. As a scripting library in your decompiler


  With the exception of Ghidra (see below), when you start your decompiler you will have a new context menu
  which you can access when you right-click anywhere in a function:

  <img src="./assets/ida_daila.png" style="width: 50%;" alt="DAILA context menu"/>

  If you are using Ghidra, go to `Tools->DAILA->Start DAILA Backend` to start the backend server.
  After you've done this, you can use the context menu as shown above.


  You can use DAILA in your own scripts by importing the `dailalib` package.
  Here is an example using the OpenAI API:

  ```python
  from dailalib import LiteLLMAIAPI
  from libbs.api import DecompilerInterface

  deci = DecompilerInterface.discover()
  ai_api = LiteLLMAIAPI(decompiler_interface=deci)
  for function in deci.functions:
      summary = ai_api.summarize_function(function)
  ```


  If you are attempting to install DAILA for a one-shot install that will not use the internet after install, like on a secure network, you can use our Docker container.
  You should either build the container yourself, save the image to a tarball, and then load it on the target machine, or you can use our pre-built image.
  You can build the container yourself by running `docker build -t daila .` in the root of this repo.
  You can also download our pre-built image by running `docker pull binsync/daila:latest` (the image is for x86_64 Linux).
  The container contains DAILA and a copy of Ghidra.

  Now you need to foward X11 to the container so that you can see the GUI.
  To do this, you need to run the container with the following flags:
  ```bash
  docker run -it --rm -e DISPLAY=$DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix binsync/daila:latest
  ```

  In the container, you can launch ghidra from `/tools/ghidra_10.4_PUBLIC/ghidraRun`.
  Now follow the [Ghidra Extra Steps](#ghidra-extra-steps) to enable the DAILA plugin and you're good to go!



  DAILA supports the LiteLLM API, which in turn supports various backends like OpenAI.
  To use a commercial LLM API, you must provide your own API key.
  As an example, to use the OpenAI API, you must have an OpenAI API key.
  If your decompiler does not have access to the `OPENAI_API_KEY` environment variable, then you must use the decompiler option from
  DAILA to set the API key.

  In `Settings`, you can also add/use any OpenAI-based LLM endpoint, like using Llama2.

  Currently, DAILA supports the following prompts:
  - Summarize a function
  - Rename variables
  - Rename function
  - Identify the source of a function
  - Find potential vulnerabilities in a function
  - Summarize the man page of a library call
  - Free prompting... just type in your own prompt!


  VarBERT is a local BERT model from the S&P 2024 paper [""Len or index or count, anything but v1": Predicting Variable Names in Decompilation Output with Transfer Learning"]().
  VarBERT is for renaming variables (both stack, register, and arguments) in decompilation.
  To understand how to use VarBERT as a library, please see the [VarBERT API](https://github.com/binsync/varbert_api) documentation.
  Using it in DAILA is a simple as using the GUI context-menu when clicking on a function.


  You can find a demo of VarBERT running inside DAILA below:

  [![VarBERT Demo](https://img.youtube.com/vi/nUazQm8sFL8/0.jpg)](https://youtu.be/nUazQm8sFL8 "DAILA v2.1.4: Renaming variables with local VarBERT model")



  - IDA
  ![](./assets/ida_daila.png)

  - Binja
  ![](./assets/binja_daila.png)

  - Ghidra
  ![](./assets/ghidra_daila.png)

  - angr management
  ![](./assets/am_daila.png)


pkgId: bc71f71f9001df031743173748afc011d3438aaf601ea2be1a0e3a538c0a98f0
name: python-daily-python
arch: noarch
version: 0.14.0
epoch: 0
release: 1
summary: Daily Client SDK for Python
url: https://pypi.org/project/daily-python/
rpm_license: BSD 2-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-daily-python-0.14.0-1.src.rpm
location_href: Packages/python-daily-python-0.14.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/daily-python)](https://pypi.org/project/daily-python)
  [![Docs](https://img.shields.io/badge/API-docs-00CC00)](https://reference-python.daily.co/)



  The Daily client SDK for Python allows you to build video and audio calling into your native desktop and server applications.

  ![daily-python](https://github.com/daily-co/daily-python/blob/main/daily-python.gif?raw=true)

  This SDK is well suited to build AI applications on the server side as it can be
  easily integrated with well-known Python libraries such as
  [OpenAI](https://github.com/openai/openai-python),
  [Deepgram](https://github.com/deepgram/deepgram-python-sdk),
  [YOLOv5](https://github.com/ultralytics/yolov5), [PyTorch](https://pytorch.org),
  [OpenCV](https://opencv.org/) and much more.

  The SDK's core features include:

  - Joining a Daily meeting as a participant
  - As a meeting participant, configuring inputs, publishing, and subscription settings
  - Receiving video frames from other participants
  - Receiving raw audio from all participants in the meeting
  - Sending video into a meeting
  - Sending raw audio into a meeting

  This functionality can be applied to several AI use cases, including:

  - Performing object or face detection on the server side
  - Processing audio from a Speech-To-Text platform into a meeting
  - Sending audio from a Text-To-Speech platform into a meeting
  - Sending video and audio tracks to a content moderation platform
  - Using generative AI to inject video content into a meeting



  See the [Daily Python API docs](https://reference-python.daily.co/index.html).

  For demos on how to use `daily-python`, refer to the [demos](https://github.com/daily-co/daily-python/tree/main/demos) directory.



  `daily-python` can be easily installed using `pip`:

  ```bash
     pip install daily-python
  ```

  To upgrade:

  ```bash
     pip install -U daily-python
  ```



  - Python 3.7 or newer



  For usage details, visit Daily's [Python SDK getting start guide](https://docs.daily.co/guides/products/ai-toolkit).



  Need help or have feedback? You can reach out through our [developer community](https://community.daily.co/) or [chat](https://www.daily.co/company/contact/support/) with our support engineers.


pkgId: 4245873137f0178e7df6f48eb67fdf982c02406980642b5dc3e9035c6fdf9045
name: python-dakiya-help
arch: noarch
version: 1.2
epoch: 0
release: 1
summary: Development documents and examples for dakiya
url: https://pypi.org/project/dakiya/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dakiya-1.2-1.src.rpm
location_href: Packages/python-dakiya-help-1.2-1.noarch.rpm
checksum_type: sha256
description:
  ```
  make build
  make upload
  ```



  ```
  from dakiya import transmitter

  var = {
      "who": "Shamail",
      "time": "1:10",
  }
  result = transmitter.send_email("nitrox/welcome.html", to = "john.doe@example.com", subject = "Hello World!", attachments=[open("/tmp/image.png", "rb+")], **var)
  ```


pkgId: 3422ab4df642427b29c5b5d539ff2f3df5ab26e6cd740a4630d601397a122991
name: python-damo-help
arch: noarch
version: 2.6.0
epoch: 0
release: 1
summary: Development documents and examples for damo
url: https://github.com/damonitor/damo
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-damo-2.6.0-1.src.rpm
location_href: Packages/python-damo-help-2.6.0-1.noarch.rpm
checksum_type: sha256
description:
  `damo` is a user space tool for [DAMON](https://damonitor.github.io).  Using
  this, you can monitor the data access patterns of your system or workloads and
  make data access-aware memory management optimizations.


pkgId: 08bc53057ad14e694e44b48f9ceb84dfd363c509a5ed9db676bcd00976a2b65e
name: python-dank-mids-help
arch: noarch
version: 4.20.112
epoch: 0
release: 1
summary: Development documents and examples for dank-mids
url: https://github.com/BobTheBuidler/dank_mids
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dank-mids-4.20.112-1.src.rpm
location_href: Packages/python-dank-mids-help-4.20.112-1.noarch.rpm
checksum_type: sha256
description:
  Dank Mids is a EVM RPC batching library that helps reduce the number of HTTP requests to a node, saving time and resources. It automatically collects eth_call calls into [multicalls](https://github.com/makerdao/multicall#multicall-) and bundles all RPC calls together in [jsonrpc](https://www.jsonrpc.org/specification#batch) [batch](https://geth.ethereum.org/docs/interacting-with-geth/rpc/batch) calls. tl;dr: its fast as fuck.

  ![image](https://github.com/BobTheBuidler/dank_mids/assets/70677534/3ecb46aa-f33a-41bd-85fb-c6d2433c7154)

  The goal of this tool is to reduce the workload on RPC nodes and allow users to make calls to their preferred node more efficiently. This optimization is especially useful for developers writing scripts that perform large-scale blockchain analysis, as it can save development time and resources.

  ![](https://i.imgur.com/o9FUmAn.jpg)



  To install Dank Mids, use pip:

  `pip install dank-mids`



  The primary function you need to use Dank Mids is `setup_dank_w3_from_sync`. This function takes a sync Web3 instance and wraps it for async use. If using dank_mids with eth-brownie, you can just import the premade dank_web3 object as well

  Example usage of Dank Mids with web3py:

  ```python
  from dank_mids.helpers import setup_dank_w3_from_sync
  dank_web3 = setup_dank_w3_from_sync(w3)

  from dank_mids.helpers import dank_web3


  random_block = await dank_web3.eth.get_block(123)
  ```



  - [Dank Brownie Example Commented Code](./examples/dank_brownie_example.py)



  - COMING SOON: Dank Mids will also work with [ape](https://github.com/ApeWorX/ape).



  [Yearn](https://yearn.finance) big brain [Tonkers Kuma](https://github.com/tonkers-kuma) had this to say:

  ![image](https://user-images.githubusercontent.com/70677534/211255488-e76e641c-a0fe-461c-a4e5-27c45a3fea5b.png)



  You can also set `DANK_MIDS_DEMO_MODE=True` to see a visual representation of the batching in real time on your console.


pkgId: adfdfc4eea05ade9f53e99c51652fc0f1e89f21a72200cf770d7b014919ab0be
name: python-dapla-suv-tools-help
arch: noarch
version: 0.1.54
epoch: 0
release: 1
summary: Development documents and examples for dapla-suv-tools
url: https://pypi.org/project/dapla-suv-tools/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dapla-suv-tools-0.1.54-1.src.rpm
location_href: Packages/python-dapla-suv-tools-help-0.1.54-1.noarch.rpm
checksum_type: sha256
description:
  - `ra_number` (str, required): Skjema's RA-number.
  - `max_results` (int, optional): Maximum number of results in the result set.  A value of `0` will get ALL results. Defaults to `0`.
  - `latest_only` (bool, optional): A boolean flag to trigger a special condition. Defaults to `False`.
  - `pagination_info` (PaginationInfo, optional): An object holding pagination metadata. Defaults to `None`.
  **Returns:**
  - `dict`: A list of skjema json objects matching the RA-number

  ```python
  output = client.get_pulje_by_id(pulje_id=123)
  print(output)
  ```
  **Parameters:**
  - `pulje_id` (int): The ID of the pulje to retrieve.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: An object containing the pulje information if found, or an error message if the retrieval fails.

  ```python
  output = client.get_pulje_by_periode_id(periode_id=123)
  print(output)
  ```
  **Parameters:**
  - `periode_id` (int): The periode_id of the pulje to retrieve.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: A list of objects containing the pulje information for every pulje under the given pulje_id if found, or an error message if the retrieval fails.

  ```python
  output = client.update_pulje_by_id(pulje_id=123,altinn_tilgjengelig=datetime(2023,12,12))
  print(output)
  ```
  **Parameters:**
  - `pulje_id` (int): The pulje_id of the pulje to update.
  - `altinn_tilgjengelig` (Optional[datetime]): Date and time for altinn_tilgjengelig.
  - `altinn_svarfrist` (Optional[date]): Date for altinn_svarfrist.
  - `tvangsmulkt_svarfrist` (Optional[date]): Date for tvangsmulkt_svarfrist.
  - `send_si` (Optional[date]): Date for send_si.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: An object containing the updated pulje information, or an error message if the update fails.

  ```python
  output = client.update_pulje_by_periode_id(periode_id=123, pulje_nr=1, altinn_tilgjengelig=datetime(2023,12,12))
  print(output)
  ```
  **Parameters:**
  - `periode_id` (int): The periode_id of the pulje to update.
  - `pulje_nr` (int): The pulje_nr of the pulje to update.
  - `altinn_tilgjengelig` (Optional[datetime]): Date and time for altinn_tilgjengelig.
  - `altinn_svarfrist` (Optional[date]): Date for altinn_svarfrist.
  - `tvangsmulkt_svarfrist` (Optional[date]): Date for tvangsmulkt_svarfrist.
  - `send_si` (Optional[date]): Date for send_si.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: An object containing the updated pulje information, or an error message if the update fails.

  ```python
  output = client.create_pulje(periode_id=123)
  print(output)
  ```
  **Parameters:**
  - `periode_id` (int): The periode_id of the pulje to create.
  - `pulje_nr` (Optional[int]): The pulje_nr of the pulje to create.
  - `altinn_tilgjengelig` (Optional[datetime]): Date and time for altinn_tilgjengelig.
  - `altinn_svarfrist` (Optional[date]): Date for altinn_svarfrist.
  - `tvangsmulkt_svarfrist` (Optional[date]): Date for tvangsmulkt_svarfrist.
  - `send_si` (Optional[date]): Date for send_si.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: An object containing the ID of the new pulje,  or an error message if the creation fails.

  ```python
  output = client.delete_pulje(pulje_id=123)
  print(output)
  ```
  **Parameters:**
  - `pulje_id` (int): The pulje_id of the pulje to delete.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: An object containing the ID of the deleted pulje, or an error message of the deletion fails.

  ```python
  output = client.get_prefill_meta_by_skjema_id(skjema_id=123)
  print(output)
  ```
  **Parameters:**
  - `skjema_id` (int): The ID of the skjema.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: A list of objects containing meta data for skjema's matching the supplied id, or an error message if the retrieval fails.

  ```python
  output = client.get_utvalg_from_sfu(delreg_nr="123456789", ra_nummer="123456789", pulje="123456789")
  print(output)
  ```
  **Parameters:**
  - `delreg_nr` (int): The delreg number of the selection.
  - `ra_nummer` (str): Skjema's RA-number, e.g. 'RA-1234'.
  - `pulje` Optional(str): Limit the selection by pulje.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: A list of objects with the selection, or an error message of the deletion fails.

  ```python
  output = client.get_enhet_from_sfu(delreg_nr="123456789", orgnr="123456789")
  print(output)
  ```
  **Parameters:**
  - `delreg_nr` (int): The delreg number of the selection.
  - `orgnr` (str): The organization number of the unit.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: An object with the organization, or an error message of the deletion fails.


pkgId: e05467bf3de2b0aa0418269724f8e2fadd9151066c771410a2d0dff3e2e9e57e
name: python-dapla-toolbelt-help
arch: noarch
version: 3.2.2
epoch: 0
release: 1
summary: Development documents and examples for dapla-toolbelt
url: https://github.com/statisticsnorway/dapla-toolbelt
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dapla-toolbelt-3.2.2-1.src.rpm
location_href: Packages/python-dapla-toolbelt-help-3.2.2-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/dapla-toolbelt.svg)][pypi status]
  [![Status](https://img.shields.io/pypi/status/dapla-toolbelt.svg)][pypi status]
  [![Python Version](https://img.shields.io/pypi/pyversions/dapla-toolbelt)][pypi status]
  [![License](https://img.shields.io/pypi/l/dapla-toolbelt)][license]

  [![Documentation](https://github.com/statisticsnorway/dapla-toolbelt/actions/workflows/docs.yml/badge.svg)][documentation]
  [![Tests](https://github.com/statisticsnorway/dapla-toolbelt/actions/workflows/tests.yml/badge.svg)][tests]
  [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=statisticsnorway_dapla-toolbelt&metric=coverage&token=b96c38fb7274dc756da920ad8bf22a73d86e6d5f)](https://sonarcloud.io/summary/new_code?id=statisticsnorway_dapla-toolbelt)
  [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=statisticsnorway_dapla-toolbelt&metric=alert_status&token=b96c38fb7274dc756da920ad8bf22a73d86e6d5f)](https://sonarcloud.io/summary/new_code?id=statisticsnorway_dapla-toolbelt)

  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)][pre-commit]
  [![Black](https://img.shields.io/badge/code%20style-black-000000.svg)][black]
  [![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)
  [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)][poetry]

  [pypi status]: https://pypi.org/project/dapla-toolbelt/
  [documentation]: https://statisticsnorway.github.io/dapla-toolbelt
  [tests]: https://github.com/statisticsnorway/dapla-toolbelt/actions?workflow=Tests

  [sonarcov]: https://sonarcloud.io/summary/overall?id=statisticsnorway_dapla-toolbelt
  [sonarquality]: https://sonarcloud.io/summary/overall?id=statisticsnorway_dapla-toolbelt
  [pre-commit]: https://github.com/pre-commit/pre-commit
  [black]: https://github.com/psf/black
  [poetry]: https://python-poetry.org/

  Python module for use within Jupyterlab notebooks, specifically aimed for Statistics Norway's data platform called
  `Dapla`. It contains support for authenticated access to Google Services such as Google Cloud Storage (GCS) and custom
  Dapla services such as [Maskinporten Guardian](https://github.com/statisticsnorway/maskinporten-guardian). The
  authentication process is based on the [TokenExchangeAuthenticator](https://github.com/statisticsnorway/jupyterhub-extensions/tree/main/TokenExchangeAuthenticator)
  for Jupyterhub.



  These operations are supported:
  * List contents of a bucket
  * Open a file in GCS
  * Copy a file from GCS into local
  * Load a file (CSV, JSON or XML) from GCS into a pandas dataframe
  * Save contents of a data frame into a file (CSV, JSON, XML) in GCS

  When the user gives the path to a resource, they do not need to give the GCS uri, only the path.
  This just means users don't have to prefix a path with "gs://".
  It is implicitly understood that all resources accessed with this tool are located in GCS,
  with the first level of the path being a GCS bucket name.



  - Python >3.8 (3.10 is preferred)
  - Poetry, install via `curl -sSL https://install.python-poetry.org | python3 -`



  You can install _Dapla Toolbelt_ via [pip] from [PyPI]:

  ```console
  pip install dapla-toolbelt
  ```



  ``` python
  from dapla import FileClient
  from dapla import GuardianClient
  import pandas as pd


  response = GuardianClient.call_api("https://data.udir.no/api/kag", "88ace991-7871-4ccc-aaec-8fb6d78ed04e", "udir:datatilssb")
  data_json = response.json()

  raw_data_df = pd.DataFrame(data_json)  # create pandas data frame from json
  raw_data_df.head()  # show first rows of data frame

  FileClient.ls("bucket-name/folder")  # list contents of given folder


  path_base = "bucket-name/folder/raw_data"
  FileClient.save_pandas_to_json(raw_data_df, f"{path_base}.json")  # generate json from data frame, and save to given path
  FileClient.save_pandas_to_csv(raw_data_df, f"{path_base}.csv")  # generate csv from data frame, and save to given path
  FileClient.save_pandas_to_xml(raw_data_df, f"{path_base}.xml")  # generate xml from data frame, and save to given path

  FileClient.cat(f"{path_base}.json")  # print contents of file



  df = FileClient.load_json_to_pandas(f"{path_base}.json")  # read json from path and load into pandas data frame
  df.head()  # show first rows of data frame
  df = FileClient.load_csv_to_pandas(f"{path_base}.csv")  # read csv from path and load into pandas data frame
  df.head()  # show first rows of data frame
  df = FileClient.load_xml_to_pandas(f"{path_base}.xml")  # read xml from path and load into pandas data frame
  df.head()  # show first rows of data frame

  ```



  Contributions are very welcome.
  To learn more, see the [Contributor Guide].



  Distributed under the terms of the [MIT license][license],
  _Dapla Toolbelt_ is free and open source software.



  If you encounter any problems,
  please [file an issue] along with a detailed description.



  This project was generated from [Statistics Norway]'s [SSB PyPI Template].

  [statistics norway]: https://www.ssb.no/en
  [pypi]: https://pypi.org/
  [ssb pypi template]: https://github.com/statisticsnorway/ssb-pypitemplate
  [file an issue]: https://github.com/statisticsnorway/dapla-toolbelt/issues
  [pip]: https://pip.pypa.io/

  <!-- github-only -->

  [license]: https://github.com/statisticsnorway/dapla-toolbelt/blob/main/LICENSE
  [contributor guide]: https://github.com/statisticsnorway/dapla-toolbelt/blob/main/CONTRIBUTING.md
  [reference guide]: https://statisticsnorway.github.io/dapla-toolbelt/reference.html


pkgId: 28e1a9f8ddf11cae6a2ac757a752c96b3a00ab8b6d0de5a509b50dc5cfb9500e
name: python-daplapath-help
arch: noarch
version: 1.1.1
epoch: 0
release: 1
summary: Development documents and examples for daplapath
url: https://pypi.org/project/daplapath/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-daplapath-1.1.1-1.src.rpm
location_href: Packages/python-daplapath-help-1.1.1-1.noarch.rpm
checksum_type: sha256
description:
  ```python
  import dapla as dp
  import pandas as pd
  from daplapath.path import Path
  ```
  ```python
  folder = Path('ssb-kart-data-delt-geo-prod/analyse_data/klargjorte-data/2024')
  folder
  ```
      'ssb-kart-data-delt-geo-prod/analyse_data/klargjorte-data/2024'

  ```python
  folder.startswith("ssb")
  ```
      True
  ```python
  dp.FileClient.get_gcs_file_system().exists(folder)
  ```
      True

  ```python
  folder.exists()
  ```
      True
  ```python
  folder.is_dir()
  ```
      True
  ```python
  file = folder / "ABAS_kommune_utenhav_p2024_v1.parquet"
  file
  ```
      'ssb-kart-data-delt-geo-prod/analyse_data/klargjorte-data/2024/ABAS_kommune_utenhav_p2024_v1.parquet'
  ```python
  file.parent
  ```
      'ssb-kart-data-delt-geo-prod/analyse_data/klargjorte-data/2024'

  Uten å lese filen
  ```python
  file.columns
  ```
      Index(['OBJTYPE', 'NAVN', 'KOMMUNENR', 'FYLKE', 'AREAL_GDB', 'SHAPE_Length',
             'SHAPE_Area', 'geometry'],
            dtype='object')
  ```python
  file.dtypes
  ```
      OBJTYPE         string
      NAVN            string
      KOMMUNENR       string
      FYLKE           string
      AREAL_GDB       double
      SHAPE_Length    double
      SHAPE_Area      double
      geometry        binary
      dtype: object
  ```python
  file.shape
  ```
      (481, 8)

  ```python
  file.version_number
  ```
      1
  ```python
  print(file.versions())
  ```
      timestamp            mb (int)
      2024-05-19 12:31:02  941            .../ABAS_kommune_utenhav_p2024.parquet
      2024-08-16 16:15:10  941         .../ABAS_kommune_utenhav_p2024_v1.parquet
      Name: path, dtype: object
  ```python
  file.latest_version()
  ```
      'ssb-kart-data-delt-geo-prod/analyse_data/klargjorte-data/2024/ABAS_kommune_utenhav_p2024_v1.parquet'
  ```python
  file.highest_numbered_version()
  ```
      'ssb-kart-data-delt-geo-prod/analyse_data/klargjorte-data/2024/ABAS_kommune_utenhav_p2024_v1.parquet'
  ```python

  file.new_version()
  ```
      'ssb-kart-data-delt-geo-prod/analyse_data/klargjorte-data/2024/ABAS_kommune_utenhav_p2024_v2.parquet'
  ```python

  file.new_version().exists()
  ```
      False
  ```python

  file._version_pattern
  ```
      '_v(\\d+)'

  Filtre med hyperlenke. Gjør at man kopierer stien når man klikker på den.
  ```python
  print(
      Path("ssb-kart-data-delt-geo-prod/analyse_data/klargjorte-data").tree()
  )
  ```
      ssb-kart-data-delt-geo-prod/analyse_data/klargjorte-data /
          └──2000 /
              └──SSB_tettsted_flate_p2000.parquet
              └──SSB_tettsted_flate_p2000_v1.parquet
          └──2002 /
              └──SSB_tettsted_flate_p2002.parquet
              └──SSB_tettsted_flate_p2002_v1.parquet
          └──2003 /
              └──SSB_tettsted_flate_p2003.parquet
              └──SSB_tettsted_flate_p2003_v1.parquet
          └──2004 /
              └──SSB_tettsted_flate_p2004.parquet
              └──SSB_tettsted_flate_p2004_v1.parquet
          └──2005 /
              └──SSB_tettsted_flate_p2005.parquet
              └──SSB_tettsted_flate_p2005_v1.parquet
          └──2006 /
              └──SSB_tettsted_flate_p2006.parquet
              └──SSB_tettsted_flate_p2006_v1.parquet
          └──2007 /
              └──SSB_tettsted_flate_p2007.parquet
              └──SSB_tettsted_flate_p2007_v1.parquet
          └──2008 /
              └──SSB_tettsted_flate_p2008.parquet
              └──SSB_tettsted_flate_p2008_v1.parquet
              └──SSB_tettsted_ringbuffer_p2008.parquet
              └──(...)
          └──2009 /
              └──SSB_tettsted_flate_p2009.parquet
              └──SSB_tettsted_flate_p2009_v1.parquet
          └──2010 /
              └──SOL_arealressurs_flate_p2010.parquet
              └──SOL_arealressurs_flate_p2010_v1.parquet
          └──2011 /
              └──SOL_Arstat_flate_p2011.parquet
              └──SOL_Arstat_flate_p2011_v1.parquet
              └──SSB_tettsted_flate_p2011.parquet
              └──(...)
          └──2012 /
              └──ABAS_fylke_flate_p2012_v1.parquet
              └──ABAS_fylke_linje_p2012_v1.parquet
              └──ABAS_grunnkrets_flate_p2012_v1.parquet
              └──(...)
          └──2013 /
              └──ABAS_fylke_flate_p2013_v1.parquet
              └──ABAS_kommune_flate_p2013_v1.parquet
              └──DEK_eiendom_flate_p2013_v1.parquet
              └──(...)
          └──2014 /
              └──DEK_eiendom_flate_p2014_v1.parquet
              └──FKB_anlegg_flate_p2014_v1.parquet
              └──FKB_anlegg_linje_p2014_v1.parquet
              └──(...)
          └──2015 /
              └──ABAS_grunnkrets_flate_p2015_v1.parquet
              └──ABAS_grunnkrets_utenhav_p2015_v1.parquet
              └──ABAS_kommune_flate_p2015_v1.parquet
              └──(...)
          └──2016 /
              └──ABAS_fylke_flate_p2016_v1.parquet
              └──ABAS_grunnkrets_flate_p2016_v1.parquet
              └──ABAS_grunnkrets_utenhav_p2016_v1.parquet
              └──(...)
          └──2017 /
              └──ABAS_fylke_flate_p2017_v1.parquet
              └──ABAS_grunnkrets_flate_p2017_v1.parquet
              └──ABAS_grunnkrets_utenhav_p2017_v1.parquet
              └──(...)
          └──2018 /
              └──ABAS_fylke_flate_p2018_v1.parquet
              └──ABAS_grunnkrets_flate_p2018_v1.parquet
              └──ABAS_grunnkrets_utenhav_p2018_v1.parquet
              └──(...)
          └──2019 /
              └──ABAS_fylke_flate_p2019_v1.parquet
              └──ABAS_grunnkrets_flate_p2019_v1.parquet
              └──ABAS_grunnkrets_utenhav_p2019_v1.parquet
              └──(...)
          └──2020 /
              └──ABAS_fylke_flate_p2020_v1.parquet
              └──ABAS_grunnkrets_flate_p2020_v1.parquet
              └──ABAS_grunnkrets_utenhav_p2020_v1.parquet
              └──(...)
          └──2021 /
              └──ABAS_fylke_flate_p2021_v1.parquet
              └──ABAS_grunnkrets_flate_p2021_v1.parquet
              └──ABAS_grunnkrets_utenhav_p2021_v1.parquet
              └──(...)
          └──2022 /
              └──ABAS_fylke_flate_p2022_v1.parquet
              └──ABAS_grunnkrets_flate_p2022_v1.parquet
              └──ABAS_grunnkrets_utenhav_p2022_v1.parquet
              └──(...)
          └──2023 /
              └──ABAS_KnrGamle_p2023_v1.parquet
              └──ABAS_fylke_flate_p2023_v1.parquet
              └──ABAS_grunnkrets_flate_p2023_v1.parquet
              └──(...)
          └──2024 /
              └──ABAS_fylke_flate_p2024_v1.parquet
              └──ABAS_grunnkrets_flate_p2024_v1.parquet
              └──ABAS_grunnkrets_utenhav_p2024_v1.parquet
              └──(...)

  Med stier som kopieres (som ctrl + c) når man klipper på stien.
  ```python
  files_in_dir = file.parent.ls()
  print(files_in_dir)
  ```
      timestamp            mb (int)
      2024-04-19 11:44:12  11                       .../ABAS_kommune_flate_p2024_v1.parquet
      2024-04-19 11:45:47  0                    .../N50_JernbaneStasjon_punkt_p2024.parquet
                           0                 .../N50_JernbaneStasjon_punkt_p2024_v1.parquet
                           0                           .../N50_lufthavn_punkt_p2024.parquet
                           0                        .../N50_lufthavn_punkt_p2024_v1.parquet
      2024-08-21 14:47:12  861                              .../SSB_hav_flate_p2024.parquet
      2024-08-23 14:59:30  152                      .../SSB_tettsted_flate_p2024_v1.parquet
      2024-08-23 14:59:36  152              .../SSB_tettsted_kommune_flate_p2024_v1.parquet
      2024-08-23 15:34:21  1122        .../SSB_tettsted_kommune_ringbuffer_p2024_v1.parquet
      2024-08-23 17:11:32  740                          .../NVDB_veg_linje_p2024_v1.parquet
      Name: path, Length: 127, dtype: object
  ```python

  type(files_in_dir)
  ```
      daplapath.path.PathSeries
  ```python
  print(files_in_dir.loc[lambda x: x.gb > 10].keep_latest_versions())
  ```
      timestamp            mb (int)
      2024-07-18 00:13:09  17646        .../FKB_arealressurs_flate_p2024_v1.parquet
      2024-08-20 14:03:16  19717       .../FKB_gronnstruktur_flate_p2024_v1.parquet
      Name: path, dtype: object
  ```python

  type(files_in_dir.iloc[0])
  ```
      daplapath.path.Path
  ```python

  print(folder.ls().files)
  ```
      timestamp            mb (int)
      2024-04-19 11:44:12  11                       .../ABAS_kommune_flate_p2024_v1.parquet
      2024-04-19 11:45:47  0                    .../N50_JernbaneStasjon_punkt_p2024.parquet
                           0                 .../N50_JernbaneStasjon_punkt_p2024_v1.parquet
                           0                           .../N50_lufthavn_punkt_p2024.parquet
                           0                        .../N50_lufthavn_punkt_p2024_v1.parquet
      2024-08-21 14:47:12  861                              .../SSB_hav_flate_p2024.parquet
      2024-08-23 14:59:30  152                      .../SSB_tettsted_flate_p2024_v1.parquet
      2024-08-23 14:59:36  152              .../SSB_tettsted_kommune_flate_p2024_v1.parquet
      2024-08-23 15:34:21  1122        .../SSB_tettsted_kommune_ringbuffer_p2024_v1.parquet
      2024-08-23 17:11:32  740                          .../NVDB_veg_linje_p2024_v1.parquet
      Name: path, Length: 127, dtype: object
  ```python
  print(folder.ls().dirs)
  ```
      Series([], Name: path, dtype: object)
  ```python

  print(folder.ls().containing("kommune"))
  ```
      timestamp            mb (int)
      2024-04-19 11:44:12  11                       .../ABAS_kommune_flate_p2024_v1.parquet
      2024-05-19 12:31:02  941                       .../ABAS_kommune_utenhav_p2024.parquet
      2024-06-24 14:25:14  11                          .../ABAS_kommune_flate_p2024.parquet
      2024-08-16 16:15:10  941                    .../ABAS_kommune_utenhav_p2024_v1.parquet
      2024-08-23 14:59:36  152              .../SSB_tettsted_kommune_flate_p2024_v1.parquet
      2024-08-23 15:34:21  1122        .../SSB_tettsted_kommune_ringbuffer_p2024_v1.parquet
      Name: path, dtype: object
  ```python
  print(file.parent.parent.ls(recursive=True).files)
  ```
      timestamp            mb (int)
      2024-04-19 11:43:21  0                 .../2022/N50_JernbaneStasjon_punkt_p2022_v1.parquet
      2024-04-19 11:43:22  0                        .../2022/N50_lufthavn_punkt_p2022_v1.parquet
      2024-04-19 11:43:23  0                      .../2022/NVE_Vindturbin_punkt_p2022_v1.parquet
                           0                    .../2022/NVE_Trafostasjon_punkt_p2022_v1.parquet
      2024-04-19 11:43:24  0                     .../2022/S100_TekniskSit_flate_p2022_v1.parquet
      2024-08-21 14:47:12  861                              .../2024/SSB_hav_flate_p2024.parquet
      2024-08-23 14:59:30  152                      .../2024/SSB_tettsted_flate_p2024_v1.parquet
      2024-08-23 14:59:36  152              .../2024/SSB_tettsted_kommune_flate_p2024_v1.parquet
      2024-08-23 15:34:21  1122        .../2024/SSB_tettsted_kommune_ringbuffer_p2024_v1.parquet
      2024-08-23 17:11:32  740                          .../2024/NVDB_veg_linje_p2024_v1.parquet
      Length: 1323, dtype: object

  ```python
  testpath = Path('ssb-areal-data-produkt-prod/arealstat/temp/test_df_p2023_v1.parquet')

  for version in testpath.versions():
      version.rm_file()
  testpath.exists()
  ```
      False
  ```python
  df = pd.DataFrame({"x": [1,2,3], "y": [*"abc"]})
  dp.write_pandas(df, testpath)
  testpath.exists()
  ```
      True
  ```python
  testpath.latest_version()
  ```
      'ssb-areal-data-produkt-prod/arealstat/temp/test_df_p2023_v1.parquet'
  ```python

  testpath.new_version()


pkgId: ba5d9e92251f32324c0b23eae4a9d06833a425113a1b043c8fcb3c733a6f56d6
name: python-daqopen-lib-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for daqopen-lib
url: https://github.com/DaqOpen/daqopen-lib
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-daqopen-lib-0.5.0-1.src.rpm
location_href: Packages/python-daqopen-lib-help-0.5.0-1.noarch.rpm
checksum_type: sha256
description:
  This library can be used for various data acquisition tasks to proper handle streaming ADC data for building data acquisition applications.

  **Documentation** incl. tutorials can be found here: [docs.daqopen.com](https://docs.daqopen.com)

  Initially, it is build around the Arduino Due, which has a high-speed ADC with good accuracy and a data transfer via USB 2.0. Most of the examples and driver uses this model together with the firmware which can be found in the firmware folder.

  ![Schema-Bild](resources/scheme-overview.png)



  - **ADC driver:** Driver for communicating with Arduino Due (included firmware) and packing the data to numpy arrays.
  - **Circular Channel Buffer:** A class representing a circular buffer for holding needed amount of data for viewing, calculating and storing.
  - **DAQ-Info Class:** Can be used to exchange informations regarding the interpretation of the data packages. It holds adjustment values and info about the acquisition rate.
  - **ZMQ-Support:** Transfer the acquired data in realtime via zmq to other applications or hosts



  This library should be used if:

  - you build long-running acquisition applications (e.g. measurement devices)



  Installation from pypi:

  ```bash
  pip install daqopen-lib
  ```

  Install latest directly from Github:

  ```
  git clone https://github.com/DaqOpen/daqopen-lib.git
  cd daqopen-lib
  pip install -e .
  ```





  ```python
  from daqopen.duedaq import DueDaq
  import matplotlib.pyplot as plt


  myDaq = DueDaq(serial_port_name="SIM")


  myDaq.start_acquisition()


  for i in range(10):
      data = myDaq.read_data()


  myDaq.stop_acquisition()


  plt.plot(data)
  plt.show()
  ```

  ![image-20241010124001678](resources/sim-first-acq.png)







  - Download Arduino IDE for your plattform and start the app
  - Install the Package to support SAM-Controllers:  Arduino SAM Boards (32-bits ARM Cortex-
    M3) by Arduino of version **1.6.12**



  - Open the sketch-file from firmware/due-daq/due-daq.ino
  - Connect the Arduino Due to the "Programming Port" (the port near to the power socket)
  - Compile and upload the firmware
  - Disconnect from the "Programming Port"



  Now, connect the "Native USB Port" (the port near the reset toggle) and use the following sketch for testing the Arduino acquisition:

  ```python
  from daqopen.duedaq import DueDaq
  import matplotlib.pyplot as plt


  myDaq = DueDaq()


  myDaq.start_acquisition()
  for i in range(10):
      data = myDaq.read_data() # read buffer


  myDaq.stop_acquisition()


  plt.plot(data)
  plt.show()
  ```

  You should see something like this:

  ![my-first-acq-1](resources/my-first-acq-1.png)

  Congratulations!

  For more Examples see [docs.daqopen.com](https://docs.daqopen.com)



  A quick and dirty roadmap to show what is planned for the future:

  - [ ] More practical examples
  - [ ] Raspberry Pi Pico as DAQ device
  - [ ] ...



  I welcome contributions to **DaqOpen**! If you'd like to contribute, please fork the repository, create a new branch, and submit a pull request.



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

  ![Logo_200px](resources/Logo_200px.png)


pkgId: c4f7684117813d8aad870215a01992b129e16227b74e8e99ceae8985e035a137
name: python-darwin-py-help
arch: noarch
version: 1.1.2
epoch: 0
release: 1
summary: Development documents and examples for darwin-py
url: https://docs.v7labs.com/reference/getting-started-2
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-darwin-py-1.1.2-1.src.rpm
location_href: Packages/python-darwin-py-help-1.1.2-1.noarch.rpm
checksum_type: sha256
description:
  Once installed, `darwin` is accessible as a command line tool.
  A useful way to navigate the CLI usage is through the help command `-h/--help` which will
  provide additional information for each command available.

  To perform remote operations on Darwin you first need to authenticate.
  This requires a [team-specific API-key](https://darwin.v7labs.com/?settings=api-keys).
  If you do not already have a Darwin account, you can [contact us](https://www.v7labs.com/contact) and we can set one up for you.
  To start the authentication process:
  ```
  $ darwin authenticate
  API key:
  Make example-team the default team? [y/N] y
  Datasets directory [~/.darwin/datasets]:
  Authentication succeeded.
  ```
  You will be then prompted to enter your API-key, whether you want to set the corresponding team as
  default and finally the desired location on the local file system for the datasets of that team.
  This process will create a configuration file at `~/.darwin/config.yaml`.
  This file will be updated with future authentications for different teams.

  Lists a summary of local existing datasets
  ```
  $ darwin dataset local
  NAME            IMAGES     SYNC_DATE         SIZE
  mydataset       112025     yesterday     159.2 GB
  ```
  Lists a summary of remote datasets accessible by the current user.
  ```
  $ darwin dataset remote
  NAME                       IMAGES     PROGRESS
  example-team/mydataset     112025        73.0%
  ```

  To create an empty dataset remotely:
  ```
  $ darwin dataset create test
  Dataset 'test' (example-team/test) has been created.
  Access at https://darwin.v7labs.com/datasets/579
  ```
  The dataset will be created in the team you're authenticated for.
  To delete the project on the server:
  ```
  $ darwin dataset remove test
  About to delete example-team/test on darwin.
  Do you want to continue? [y/N] y
  ```

  Uploads data to an existing remote project.
  It takes the dataset name and a single image (or directory) with images/videos to upload as
  parameters.
  The `-e/--exclude` argument allows to indicate file extension/s to be ignored from the data_dir.
  e.g.: `-e .jpg`
  For videos, the frame rate extraction rate can be specified by adding `--fps <frame_rate>`
  Supported extensions:
  - Video files: [`.mp4`, `.bpm`, `.mov` formats].
  - Image files [`.jpg`, `.jpeg`, `.png` formats].
  ```
  $ darwin dataset push test /path/to/folder/with/images
  100%|████████████████████████| 2/2 [00:01<00:00,  1.27it/s]
  ```
  Before a dataset can be downloaded, a release needs to be generated:
  ```
  $ darwin dataset export test 0.1
  Dataset test successfully exported to example-team/test:0.1
  ```
  This version is immutable, if new images / annotations have been added you will have to create a new release to included them.
  To list all available releases
  ```
  $ darwin dataset releases test
  NAME                           IMAGES     CLASSES                   EXPORT_DATE
  example-team/test:0.1               4           0     2019-12-07 11:37:35+00:00
  ```
  And to finally download a release.
  ```
  $ darwin dataset pull test:0.1
  Dataset example-team/test:0.1 downloaded at /directory/choosen/at/authentication/time .


pkgId: d220c6d8a85c376e456fac1a219c40447720fd0162289cf8e379ae9fa1e67a92
name: python-dash-paperdragon-help
arch: noarch
version: 0.1.7
epoch: 0
release: 1
summary: Development documents and examples for dash-paperdragon
url: https://pypi.org/project/dash-paperdragon/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dash-paperdragon-0.1.7-1.src.rpm
location_href: Packages/python-dash-paperdragon-help-0.1.7-1.noarch.rpm
checksum_type: sha256
description:
  Dash PaperDragon is a Dash component library.

  OpenSeaDragon and PaperJS component for Dash and the DSA

  Get started with:
  1. Install Dash and its dependencies: https://dash.plotly.com/installation
  2. Run `python usage.py`
  3. Visit http://localhost:8050 in your web browser



  See [CONTRIBUTING.md](./CONTRIBUTING.md)



  If you have selected install_dependencies during the prompt, you can skip this part.

  1. Install npm packages
      ```
      $ npm install
      ```
  2. Create a virtual env and activate.
      ```
      $ virtualenv venv
      $ . venv/bin/activate
      ```
      _Note: venv\Scripts\activate for windows_

  3. Install python packages required to build components.
      ```
      $ pip install -r requirements.txt
      ```
  4. Install the python packages for testing (optional)
      ```
      $ pip install -r tests/requirements.txt
      ```



  - The demo app is in `src/demo` and you will import your example component code into your demo app.
  - Test your code in a Python environment:
      1. Build your code
          ```
          $ npm run build
          ```
      2. Run and modify the `usage.py` sample dash app:
          ```
          $ python usage.py
          ```
  - Write tests for your component.
      - A sample test is available in `tests/test_usage.py`, it will load `usage.py` and you can then automate interactions with selenium.
      - Run the tests with `$ pytest tests`.
      - The Dash team uses these types of integration tests extensively. Browse the Dash component code on GitHub for more examples of testing (e.g. https://github.com/plotly/dash-core-components)
  - Add custom styles to your component by putting your custom CSS files into your distribution folder (`dash_paperdragon`).
      - Make sure that they are referenced in `MANIFEST.in` so that they get properly included when you're ready to publish your component.
      - Make sure the stylesheets are added to the `_css_dist` dict in `dash_paperdragon/__init__.py` so dash will serve them automatically when the component suite is requested.
  - [Review your code](./review_checklist.md)



  1. Build your code:
      ```
      $ npm run build
      ```
  2. Create a Python distribution
      ```
      $ python setup.py sdist bdist_wheel
      ```
      This will create source and wheel distribution in the generated the `dist/` folder.
      See [PyPA](https://packaging.python.org/guides/distributing-packages-using-setuptools/#packaging-your-project)
      for more information.

  3. Test your tarball by copying it into a new environment and installing it locally:
      ```
      $ pip install dash_paperdragon-0.0.1.tar.gz
      ```

  4. If it works, then you can publish the component to NPM and PyPI:
      1. Publish on PyPI
          ```
          $ twine upload dist/*
          ```
      2. Cleanup the dist folder (optional)
          ```
          $ rm -rf dist
          ```
      3. Publish on NPM (Optional if chosen False in `publish_on_npm`)
          ```
          $ npm publish
          ```
          _Publishing your component to NPM will make the JavaScript bundles available on the unpkg CDN. By default, Dash serves the component library's CSS and JS locally, but if you choose to publish the package to NPM you can set `serve_locally` to `False` and you may see faster load times._

  5. Share your component with the community! https://community.plotly.com/c/dash
      1. Publish this repository to GitHub
      2. Tag your GitHub repository with the plotly-dash tag so that it appears here: https://github.com/topics/plotly-dash
      3. Create a post in the Dash community forum: https://community.plotly.com/c/dash


pkgId: 64e1d2a6a2709dfee04b83adeb3e47eb307e5141c5e82bd9f785713b8e7d74f4
name: python-dash-pydantic-form-help
arch: noarch
version: 0.10.1
epoch: 0
release: 1
summary: Development documents and examples for dash-pydantic-form
url: https://pydf-docs.onrender.com
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dash-pydantic-form-0.10.1-1.src.rpm
location_href: Packages/python-dash-pydantic-form-help-0.10.1-1.noarch.rpm
checksum_type: sha256
description:
  This package allows users to quickly create forms with Plotly Dash based on pydantic models.

  See the full docs at [dash-pydantic-form docs](https://pydf-docs.onrender.com).

  Check out a full self-standing example app in [usage.py](usage.py).



  Install with pip

  ```sh
  pip install dash-pydantic-form
  ```

  Create a pydantic model you would like to display a form for.

  *Note: This package uses pydantic 2.*

  ```py
  from datetime import date
  from typing import Literal
  from pydantic import BaseModel, Field

  class Employee(BaseModel):
      first_name: str = Field(title="First name")
      last_name: str = Field(title="Last name")
      office: Literal["au", "uk", "us", "fr"] = Field(title="Office")
      joined: date = Field(title="Employment date")
  ```

  Then you can get an auto-generated form with `ModelForm`, leveraging [dash-mantine-components](https://dash-mantine-components.com) (version 0.14) for form inputs.

  ```py
  from dash_pydantic_form import ModelForm


  form = ModelForm(
      Employee,
      aio_id="employees",
      form_id="new_employee",
  )
  ```

  ![Simple form](images/simple-form.png)

  You can also render a pre-filled form by passing an instance of the data model rather than the class

  ```py

  bob = Employee(first_name="Bob", last_name="K", office="au", joined="2020-05-20")

  form = ModelForm(
      bob,
      aio_id="employees",
      form_id="bob",
  )
  ```

  You can then retrieve the contents of the whole form at once in a callback as follows

  ```py
  from dash import Input, Output, callback

  @callback(
      Output("some-output-id", "some-output-attribute"),
      Input(ModelForm.ids.main("employees", "new_employee"), "data"),
  )
  def use_form_data(form_data: dict):
      try:
          print(Employee(**form_data))
      except ValidationError as exc:
          print("Could not validate form data:")
          print(exc.errors())
      return # ...
  ```



  The `ModelForm` will automaticlly pick which input type to use based on the type annotation for the model field. However, you can customise how each field input is rendered, and or pass additional props to the DMC component.

  ```py
  from dash_pydantic_form import ModelfForm, fields

  form = ModelForm(
      Employee,
      aio_id="employees",
      form_id="new_employee",
      fields_repr={
          
          
          "office": fields.RadioItems(description="Wich country office?"),
          
          "joined": {"maxDate": "2024-01-01"},
      },
  )
  ```

  You can also customise inputs by adding arguments to the fields' json_schema_extra if you don't mind mixing data and presentation layers.

  ```py
  class Employee(BaseModel):
      first_name: str = Field(title="First name")
      last_name: str = Field(title="Last name")
      office: Literal["au", "uk", "us", "fr"] = Field(
          title="Office",
          description="Wich country office?",
          
          json_schema_extra={"repr_type": "RadioItems"},
      )
      joined: date = Field(
          title="Employment date",
          
          json_schema_extra={"repr_kwargs": {"maxDate": "2024-01-01"}},
      )

  form = ModelForm(Employee, aio_id="employees", form_id="new_employee")
  ```

  Note: You can currently skip the `json_schema_extra=...` and just pass `repr_type=..., repr_kwargs=...` in the field. However, the `**extras` keyword arguments are deprecated on pydantic's `Field` so using `json_schema_extra` is more future-proof.



  Based on DMC:
  * Checkbox
  * Checklist
  * Color
  * Date
  * Json
  * Month
  * MultiSelect
  * Number
  * Password
  * RadioItems
  * Range
  * Rating
  * SegmentedControl
  * Select
  * Slider
  * Switch
  * Tags
  * Textarea
  * Text
  * Time
  * Year

  Custom:
  * Dict
  * Table
  * List
  * Markdown
  * Model
  * Path
  * Quantity
  * TransferList



  There are 2 main avenues to create form sections:



  ```py
  class HRData(BaseModel):
      office: Literal["au", "uk", "us", "fr"] = Field(title="Office")
      joined: date = Field(title="Employment date")

  class EmployeeNested(BaseModel):
      first_name: str = Field(title="First name")
      last_name: str = Field(title="Last name")
      hr_data: HRData = Field(title="HR data")
  ```
  ModelForm will then recognise HRData as a pydantic model and use the `fields.Model` to render it, de facto creating a section.

  ![Nested model](images/nested-model.png)



  ```py
  from dash_pydantic_form import FormSection, ModelForm, Sections

  form = ModelForm(
      Employee,
      aio_id="employees",
      form_id="new_employee",
      sections=Sections(
          sections=[
              FormSection(name="General", fields=["first_name", "last_name"], default_open=True),
              FormSection(name="HR data", fields=["office", "joined"], default_open=False),
          ],
          
          render="tabs",
      ),
  )
  ```

  ![Form sections](images/form-sections.png)



  Dash pydantic form also handles lists of nested models with the possibility to add/remove items from the list and edit each one.

  Let's say we now want to record the employee's pets



  This creates a list of sub-forms each of which can take similar arguments as a ModelForm (fields_repr, sections).

  ```py
  class Pet(BaseModel):
      name: str = Field(title="Name")
      species: Literal["cat", "dog"] = Field(title="Species")
      age: int = Field(title="Age")

  class Employee(BaseModel):
      first_name: str = Field(title="First name")
      last_name: str = Field(title="Last name")
      pets: list[Pet] = Field(title="Pets", default_factory=list)

  form = ModelForm(
      Employee,
      aio_id="employees",
      form_id="new_employee",
      fields_repr={
          "pets": fields.List(
              fields_repr={
                  "species": {"options_labels": {"cat": "Cat", "dog": "Dog"}}
              },
              
              render_type="accordion",
          )
      },
  )
  ```

  ![List](images/model-list.png)



  You can also represent the list of sub-models as an ag-grid table with `fields.Table`.

  ```py
  form = ModelForm(
      Employee,
      aio_id="employees",
      form_id="new_employee",
      fields_repr={
          "pets": fields.Table(
              fields_repr={
                  "species": {"options_labels": {"cat": "Cat", "dog": "Dog"}}
              },
          )
      },
  )
  ```

  ![Table](images/editable-table.png)




  You can make field visibility depend on the value of other fields in the form. To do so, simply pass a `visible` argument to the field.

  ```py
  class Employee(BaseModel):
      first_name: str
      last_name: str
      only_bob: str | None = Field(
          title="Only for Bobs",
          description="What's your favourite thing about being a Bob?",
          default=None,
      )

  form = ModelForm(
      Employee,
      aio_id="employees",
      form_id="new_employee",
      fields_repr={
          "only_bob": fields.Textarea(
              visible=("first_name", "==", "Bob"),
          )
      },
  )
  ```

  ![Conditionally visible field](images/conditionnally-visible-field.gif)

  `visible` accepts a boolean, a 3-tuple or list of 3-tuples with format: (field, operator, value). The available operators are:
  * "=="
  * "!="
  * "in"
  * "not in"
  * "array_contains"
  * "array_contains_any"

  NOTE: The field in the 3-tuples is a ":" separated path relative to the current field's level of nesting. If you need to reference a field from a parent or the root use the special values `_parent_` or `_root_`.

  E.g., `visible=("_root_:first_name", "==", "Bob")`



  Dash pydantic form supports Pydantic [discriminated unions with str discriminator](https://docs.pydantic.dev/latest/concepts/unions/#discriminated-unions-with-str-discriminators)

  ```py
  class HomeOffice(BaseModel):
      """Home office model."""

      type: Literal["home_office"]
      has_workstation: bool = Field(title="Has workstation", description="Does the employee have a suitable workstation")


  class WorkOffice(BaseModel):
      """Work office model."""

      type: Literal["work_office"]
      commute_time: int = Field(title="Commute time", description="Commute time in minutes", ge=0)

  class Employee(BaseModel):
      name: str = Field(title="Name")
      work_location: HomeOffice | WorkOffice | None = Field("Work location", default=None, discriminator="type")

  form = ModelForm(
      Employee,
      aio_id="employees",
      form_id="new_employee",
      fields_repr={
          "work_location": {
              "fields_repr": {
                  "type": fields.RadioItems(
                      options_labels={"home_office": "Home", "work_office": "Work"}
                  )
              },
          },
      }
  )
  ```

  ![Discriminated union](images/discriminated-union.gif)



  *To be written*

rpm_license:
  The MIT License (MIT)  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: 770e54baccbb0e8c0726b0f4774bab68410733ef0a8c78c436a66ec6bf9bcb94
name: python-dask-awkward-help
arch: noarch
version: 2024.12.1
epoch: 0
release: 1
summary: Development documents and examples for dask-awkward
url: https://github.com/dask-contrib/dask-awkward
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dask-awkward-2024.12.1-1.src.rpm
location_href: Packages/python-dask-awkward-help-2024.12.1-1.noarch.rpm
checksum_type: sha256
description:
  > Connecting [awkward-array](https://awkward-array.org) and
  [Dask](https://dask.org/).
  [![Tests](https://github.com/dask-contrib/dask-awkward/actions/workflows/pypi-tests.yml/badge.svg)](https://github.com/dask-contrib/dask-awkward/actions/workflows/pypi-tests.yml)
  [![Tests](https://github.com/dask-contrib/dask-awkward/actions/workflows/conda-tests.yml/badge.svg)](https://github.com/dask-contrib/dask-awkward/actions/workflows/conda-tests.yml)
  [![Documentation Status](https://readthedocs.org/projects/dask-awkward/badge/?version=latest)](https://dask-awkward.readthedocs.io/en/latest/?badge=latest)
  [![Coverage](https://codecov.io/gh/dask-contrib/dask-awkward/branch/main/graph/badge.svg)](https://codecov.io/gh/dask-contrib/dask-awkward/branch/main)
  [![PyPI](https://img.shields.io/pypi/v/dask-awkward?color=blue)](https://pypi.org/project/dask-awkward)
  [![Conda Forge](https://img.shields.io/conda/vn/conda-forge/dask-awkward.svg?colorB=486b87&style=flat)](https://anaconda.org/conda-forge/dask-awkward)


pkgId: fab0ff45cbf50afea3b4510a28401386d9a3b3498aca84df472e65ee6f405686
name: python-dask-expr-help
arch: noarch
version: 1.1.21
epoch: 0
release: 1
summary: Development documents and examples for dask-expr
url: https://pypi.org/project/dask-expr/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dask-expr-1.1.21-1.src.rpm
location_href: Packages/python-dask-expr-help-1.1.21-1.noarch.rpm
checksum_type: sha256
description:
  Dask DataFrames with query optimization.
  This is a rewrite of Dask DataFrame that includes query
  optimization and generally improved organization.
  More in our blog posts:
  - [Dask Expressions overview](https://blog.dask.org/2023/08/25/dask-expr-introduction)
  - [TPC-H benchmark results vs. Dask DataFrame](https://docs.coiled.io/blog/tpch.html)


pkgId: 6e958cfb92e4ab5b93bfa6d7e13fdde0036ef9407b7d105ee923af86938e74e1
name: python-dask-help
arch: noarch
version: 2024.12.1
epoch: 0
release: 1
summary: Development documents and examples for dask
url: https://github.com/dask/dask/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dask-2024.12.1-1.src.rpm
location_href: Packages/python-dask-help-2024.12.1-1.noarch.rpm
checksum_type: sha256
description:
  |Build Status| |Coverage| |Doc Status| |Discourse| |Version Status| |NumFOCUS|
  Dask is a flexible parallel computing library for analytics.  See
  documentation_ for more information.


pkgId: c645fb1284b440792cb3293faedeb8a985d6a76e1492d1997a96d6754d2f7129
name: python-dask-histogram-help
arch: noarch
version: 2024.12.0
epoch: 0
release: 1
summary: Development documents and examples for dask-histogram
url: https://github.com/dask-contrib/dask-histogram
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dask-histogram-2024.12.0-1.src.rpm
location_href: Packages/python-dask-histogram-help-2024.12.0-1.noarch.rpm
checksum_type: sha256
description:
  > Scale up histogramming with [Dask](https://dask.org).

  [![Tests](https://github.com/dask-contrib/dask-histogram/actions/workflows/ci.yml/badge.svg)](https://github.com/dask-contrib/dask-histogram/actions/workflows/ci.yml)
  [![Documentation Status](https://readthedocs.org/projects/dask-histogram/badge/?version=latest)](https://dask-histogram.readthedocs.io/en/latest/?badge=latest)
  [![PyPI version](https://img.shields.io/pypi/v/dask-histogram.svg?colorB=486b87&style=flat)](https://pypi.org/project/dask-histogram/)
  [![Conda Forge](https://img.shields.io/conda/vn/conda-forge/dask-histogram.svg?colorB=486b87&style=flat)](https://anaconda.org/conda-forge/dask-histogram)
  [![Python Version](https://img.shields.io/pypi/pyversions/dask-histogram)](https://pypi.org/project/dask-histogram/)

  The [boost-histogram](https://github.com/scikit-hep/boost-histogram)
  library provides a performant object oriented API for histogramming in
  Python. Building on the foundation of boost-histogram, dask-histogram
  adds support for lazy calculations on Dask collections.

  See [the documentation](https://dask-histogram.readthedocs.io/) for
  examples and the API reference.


pkgId: 28a9fd1f8d74fd4fe3d8eb93c25bb5ec35053bc86db01292d74c2fe80be0c9cc
name: python-data-analytics-core-help
arch: noarch
version: 1.0.30
epoch: 0
release: 1
summary: Development documents and examples for data-analytics-core
url: https://pypi.org/project/data-analytics-core/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-data-analytics-core-1.0.30-1.src.rpm
location_href: Packages/python-data-analytics-core-help-1.0.30-1.noarch.rpm
checksum_type: sha256
description:
  <h1>DA Core</h1>
  <h2>RTFM</h2>
  ⚛️ <b>This repo is meant to have all the globally shared modules in all Data-Analytics.</b> ⚛️

  Works with python 3.9 and higher. 💪

  ⚛️

  To install this package 💯 , paste in the console:

   <code>pip3 install --upgrade data-analytics-core</code>

  ⚛️

  <summary><h2>Steps to install and use the LocalStack module of this repo</h2></summary><blockquote>
      <details><summary>I- List of previous dependencies</summary>
          <ol>
          <li><a href="https://brew.sh/">Brew</a></li>
          <li><a href="https://docs.docker.com/desktop/install/mac-install/">Docker Desktop</a></li>
          <li>Download <a href="https://www.python.org/downloads/release/python-3916/">Python 3.9.16</a></li>
          </ol>
      </details>
      <details><summary>II- LocalStack</summary>
          To be able to use LocalStack docker instances, execute:
          <br><code>pip install localstack</code>
          <br>Then use (if you don't own a PRO account of LS):
          <br><code>docker image pull localstack/localstack:0.14.2</code>
          <br>Else use:
          <br><code>docker image pull localstack/localstack-pro:3.2.0</code>
          <br>You can also use a specific LS big data image (try the<code>latest-bigdata</code> version for cool stuff testing) or any other version of your will
      </details>
      <details><summary>III- Extra Info</summary>
          <ol>
          Before starting, open docker desktop and initialize (run) a container of the LS image.
          It is usually called <code>AWSLocalStackMock</code>
          <br>Keep in mind that if you are willing to use a pro version, you'll need to state an environment variable called:
          <br><code>LOCALSTACK_AUTH_TOKEN</code> filled with your personal LS PRO token.
          </ol>
      </details>
    </blockquote>

  ⚛️

  [!IMPORTANT] For AWS :cloud: users, we strongly recommend to install it with its dependencies,
  yet if you are deploying it inside an AWS Layer, you should make sure it has the max size boundaries from the AWS cloud,
  or deploy it in a Layer cluster that includes all its dependencies, while using the flag
  <code>--no-deps</code> in the pip command. 🧑‍🔧

  ⚛️

  For any contribution [PR](https://github.com/seatcode/data-analytics-core/pulls) 🧑‍💻, reference,
  issue, version upgrade convention or question, you can ask to any of the Authors, open an issue or
   ask directly to ⚜️@MarcVea⚜️️
  Also, you can look for any further info in the [wiki](https://github.com/seatcode/data-analytics-core/wiki),
  look for the [issues](https://github.com/seatcode/data-analytics-core/issues) and their status, or open any [discussion](https://github.com/seatcode/data-analytics-core/discussions) you might need.

  ⚛️


pkgId: cf839e68bcc155ee53597097f38d33fc1262f48948b83e5a39a83c0b6f50fe44
name: python-data-crypto-szjh-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for data-crypto-szjh
url: https://github.com/Hoodie-melon/JIAMI
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-data-crypto-szjh-0.1.1-1.src.rpm
location_href: Packages/python-data-crypto-szjh-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  一个用于数据加密和解密的Python工具包，主要用于处理数据库中的敏感信息。



  - 支持AES-256-CBC加密/解密
  - 支持批量数据处理
  - 支持数据库连接池
  - 支持导出解密后的数据到Excel
  - 多线程处理提升性能
  - 支持断点续传
  - 支持无效日期处理



  ```bash
  pip install data-crypto-szjh
  ```



  在使用前需要配置以下环境变量，可以创建 `.env` 文件：


  ```.env
  local_host=本地数据库地址
  local_user=本地数据库用户名
  local_password=本地数据库密码
  local_database=本地数据库名
  ```


  ```.env
  remote_host=远程数据库地址
  remote_user=远程数据库用户名
  remote_password=远程数据库密码
  remote_database=远程数据库名
  ```


  ```.env
  ENCRYPTION_KEY=your_encryption_key
  ```






  DataEncryptor 类用于加密数据库中的敏感字段。


  - `fields_to_encrypt`: 需要加密的字段列表
  - `batch_size`: 每批处理的记录数（默认1000）
  - `table_name`: 要处理的表名
  - `max_workers`: 工作线程数（默认4）
  - `queue_size`: 队列大小（默认10）
  - `checkpoint_file`: 断点续传文件路径
  - `timeout`: 队列等待超时时间（秒）
  - `invalid_dates`: 需要处理的无效日期列表

  ```python
  from data_crypto import encryptor

  encryptor = encryptor.DataEncryptor()
  encryptor.run()
  ```



  DataDecryptor 类用于解密数据库中的加密字段并导出到Excel文件。


  - `fields_to_decrypt`: 需要解密的字段列表
  - `table_name`: 要处理的数据表名
  - `batch_size`: 每批处理的记录数
  - `output_file`: 输出的Excel文件名

  ```python
  from data_crypto import decryptor

  decryptor = decryptor.DataDecryptor()
  decryptor.run()
  ```


pkgId: a2f7c7e4d6569f4c29126f2af7c8f0695dea1ddbe6ee0fff9a25d91f60634f38
name: python-data-manipulation-utilities-help
arch: noarch
version: 0.1.6
epoch: 0
release: 1
summary: Development documents and examples for data-manipulation-utilities
url: https://pypi.org/project/data-manipulation-utilities/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-data-manipulation-utilities-0.1.6-1.src.rpm
location_href: Packages/python-data-manipulation-utilities-help-0.1.6-1.noarch.rpm
checksum_type: sha256
description:
  fr1                                                     5.000e-01      0.000e+00      1.000e+00    1                     none
  fr2                                                     5.000e-01      0.000e+00      1.000e+00    1                     none
  mu1                                                     4.000e-01     -5.000e+00      5.000e+00    1                     none
  mu2                                                     4.000e-01     -5.000e+00      5.000e+00    1                     none
  sg1                                                     1.300e+00      0.000e+00      5.000e+00    1                     none
  sg2                                                     1.300e+00      0.000e+00      5.000e+00    1                     none
  ```
  showing basic information on the observable, the parameter ranges and values, whether they are Gaussian constrained and floating or not.
  One can add other options too:
  ```python
  from dmu.stats.utilities   import print_pdf

  d_const = {'mu1' : [0.0, 0.1], 'sg1' : [1.0, 0.1]}


  print_pdf(pdf)

  print_pdf(pdf,
            blind   = ['sg.*', 'mu.*'])

  print_pdf(pdf,
            d_const = d_const,
            blind   = ['sg.*', 'mu.*'])



  print_pdf(pdf,
            txt_path = 'tests/stats/utilities/print_pdf/pdf.txt')
  print_pdf(pdf,
            blind    =['sg.*', 'mu.*'],
            txt_path = 'tests/stats/utilities/print_pdf/pdf_blind.txt')
  print_pdf(pdf,
            d_const  = d_const,
            txt_path = 'tests/stats/utilities/print_pdf/pdf_const.txt')
  ```

  The `Fitter` class is a wrapper to zfit, use to make fitting easier.

  ```python
  from dmu.stats.fitter      import Fitter
  obj = Fitter(pdf, dat)
  res = obj.fit()
  ```

  In order to customize the way the fitting is done one would pass a configuration dictionary to the `fit(cfg=config)`
  function. This dictionary can be represented in YAML as:
  ```yaml

  strategy      :
        
        
        retry   :
            ntries        : 4    #Number of tries
            pvalue_thresh : 0.05 #Pvalue threshold, if the fit is better than this, the loop ends
            ignore_status : true #Will pick invalid fits if this is true, otherwise only valid fits will be counted
        
        
        
        steps   :
            nsteps   : [1e3, 1e4] #Number of entries to use
            nsigma   : [5.0, 2.0] #Number of sigmas for the range of the parameter, for each step
            yields   : ['ny1', 'ny2'] # in the fitting model ny1 and ny2 are the names of yields parameters, all the yield need to go in this list


  ranges        :
        - !!python/tuple [0, 3]
        - !!python/tuple [6, 9]


  constraints   :
        mu : [5.0, 1.0]
        sg : [1.0, 0.1]

  print_pars    : ['mu', 'sg']
  likelihood :
      nbins : 100 #If specified, will do binned likelihood fit instead of unbinned
  ```


  Given an array representing a distribution, the following lines will increase its size
  by `fscale`, where this number is a float, e.g. 3.4.
  ```python
  from dmu.arrays.utilities import repeat_arr
  arr_val = repeat_arr(arr_val = arr_inp, ftimes = fscale)
  ```
  in such a way that the output array will be `fscale` larger than the input one, but will keep the same distribution.

  The project contains the `Function` class that can be used to:
  - Store `(x,y)` coordinates.
  - Evaluate the function by interpolating
  - Storing the function as a JSON file
  - Loading the function from the JSON file
  It can be used as:
  ```python
  import numpy
  from dmu.stats.function    import Function
  x    = numpy.linspace(0, 5, num=10)
  y    = numpy.sin(x)
  path = './function.json'


  fun  = Function(x=x, y=y, kind='cubic')
  fun.save(path = path)
  fun  = Function.load(path)
  xval = numpy.lispace(0, 5, num=100)
  yval = fun(xval)
  ```


  To train models to classify data between signal and background, starting from ROOT dataframes do:
  ```python
  from dmu.ml.train_mva      import TrainMva
  rdf_sig = _get_rdf(kind='sig')
  rdf_bkg = _get_rdf(kind='bkg')
  cfg     = _get_config()
  obj= TrainMva(sig=rdf_sig, bkg=rdf_bkg, cfg=cfg)
  obj.run()
  ```
  where the settings for the training go in a config dictionary, which when written to YAML looks like:
  ```yaml
  training :
      nfold    : 10
      features : [w, x, y, z]
      hyper    :
        loss              : log_loss
        n_estimators      : 100
        max_depth         : 3
        learning_rate     : 0.1
        min_samples_split : 2
  saving:
      path : 'tests/ml/train_mva/model.pkl'
  plotting:
      val_dir : 'tests/ml/train_mva'
      features:
          saving:
              plt_dir : 'tests/ml/train_mva/features'
          plots:
            w :
              binning : [-4, 4, 100]
              yscale  : 'linear'
              labels  : ['w', '']
            x :
              binning : [-4, 4, 100]
              yscale  : 'linear'
              labels  : ['x', '']
            y :
              binning : [-4, 4, 100]
              yscale  : 'linear'
              labels  : ['y', '']
            z :
              binning : [-4, 4, 100]
              yscale  : 'linear'
              labels  : ['z', '']
  ```
  the `TrainMva` is just a wrapper to `scikit-learn` that enables cross-validation (and therefore that explains the `nfolds` setting).

  When training on real data, several things might go wrong and the code will try to deal with them in the following ways:
  - **Repeated entries**: Entire rows with features might appear multiple times. When doing cross-validation, this might mean that two identical entries
  will end up in different folds. The tool checks for wether a model is evaluated for an entry that was used for training and raise an exception. Thus, repeated
  entries will be removed before training.
  - **NaNs**: Entries with NaNs will break the training with the scikit GradientBoostClassifier base class. Thus, we also remove them from the training.

  Given the models already trained, one can use them with:
  ```python
  from dmu.ml.cv_predict     import CVPredict

  cvp     = CVPredict(models=l_model, rdf=rdf)

  arr_prb = cvp.predict()
  ```
  If the entries in the input dataframe were used for the training of some of the models, the model that was not used
  will be _automatically_ picked for the prediction of a specific sample.
  The picking process happens through the comparison of hashes between the samples in `rdf` and the training samples.
  The hashes of the training samples are stored in the pickled model itself; which therefore is a reimplementation of
  `GradientBoostClassifier`, here called `CVClassifier`.
  If a sample exist, that was used in the training of _every_ model, no model can be chosen for the prediction and an
  `CVSameData` exception will be risen.

  When evaluating the model with real data, problems might occur, we deal with them as follows:
  - **Repeated entries**: When there are repeated features in the dataset to be evaluated we assign the same probabilities, no filtering is used.
  - **NaNs**: Entries with NaNs will break the evaluation. These entries will be _patched_  with zeros and evaluated. However, before returning, the probabilities will be
  saved as -1. I.e. entries with NaNs will have probabilities of -1.

  These are utility functions meant to be used with ROOT dataframes.

  For this do:
  ```python
  import dmu.rdataframe.utilities as ut
  arr_val = numpy.array([10, 20, 30])
  rdf     = ut.add_column(rdf, arr_val, 'values')
  ```
  the `add_column` function will check for:
  1. Presence of a column with the same name
  2. Same size for array and existing dataframe
  and return a dataframe with the added column

  **Use case** When performing operations in dataframes, like `Filter`, `Range` etc; a new instance of the dataframe
  will be created. One might want to attach attributes to the dataframe, like the name of the file or the tree, etc.
  Those attributes will thus be dropped. In order to deal with this one can do:
  ```python
  from dmu.rdataframe.atr_mgr import AtrMgr

  obj = AtrMgr(rdf)

  rdf = rdf.Filter(x, y)
  rdf = rdf.Define('a', 'b')

  rdf = obj.add_atr(rdf)
  ```
  The attributes can also be saved to JSON with:
  ```python
  obj = AtrMgr(rdf)
  obj.to_json('/path/to/file.json')
  ```

  The `LogStore` class is an interface to the `logging` module. It is aimed at making it easier to include
  a good enough logging tool. It can be used as:
  ```python
  from dmu.logging.log_store import LogStore
  LogStore.backend = 'logging' # This line is optional, the default backend is logging, but logzero is also supported
  log = LogStore.add_logger('msg')
  LogStore.set_level('msg', 10)
  log.debug('debug')
  log.info('info')
  log.warning('warning')
  log.error('error')
  log.critical('critical')
  ```


  Given a set of ROOT dataframes and a configuration dictionary, one can plot distributions with:
  ```python
  from dmu.plotting.plotter_1d import Plotter1D as Plotter
  ptr=Plotter(d_rdf=d_rdf, cfg=cfg_dat)
  ptr.run()
  ```
  where the config dictionary `cfg_dat` in YAML would look like:
  ```yaml
  selection:
      
      max_ran_entries : 50000
      cuts:
      
        z : 'z > 0'
  saving:
      
      plt_dir : tests/plotting/high_stat
  definitions:
      
      z : 'x + y'

  plots:
      x :
          binning    : [0.98, 0.98, 40] # Here bounds agree => tool will calculate bounds making sure that they are the 2% and 98% quantile
          yscale     : 'linear' # Optional, if not passed, will do linear, can be log
          labels     : ['x', 'Entries'] # Labels are optional, will use varname and Entries as labels if not present
          title      : 'some title can be added for different variable plots'
          name       : 'plot_of_x' # This will ensure that one gets plot_of_x.png as a result, if missing x.png would be saved
      y :
          binning    : [-5.0, 8.0, 40]
          yscale     : 'linear'
          labels     : ['y', 'Entries']
      z :
          binning    : [-5.0, 8.0, 40]
          yscale     : 'linear'
          labels     : ['x + y', 'Entries']
          normalized : true #This should normalize to the area
  ```
  it's up to the user to build this dictionary and load it.

  For the 2D case it would look like:
  ```python
  from dmu.plotting.plotter_2d import Plotter2D as Plotter
  ptr=Plotter(rdf=rdf, cfg=cfg_dat)
  ptr.run()
  ```
  where one would introduce only one dataframe instead of a dictionary, given that overlaying 2D plots is not possible.
  The config would look like:
  ```yaml
  saving:
      plt_dir : tests/plotting/2d
  general:
      size : [20, 10]
  plots_2d:
      
      
      
      - [x, y, weights, 'xy_w']
      - [x, y,    null, 'xy_r']
  axes:
      x :
          binning : [-5.0, 8.0, 40]
          label   : 'x'
      y :
          binning : [-5.0, 8.0, 40]
          label   : 'y'
  ```


  The lines below will return a dictionary with trees from the handle to a ROOT file:
  ```python
  import dmu.rfile.utilities   as rfut
  ifile  = TFile("/path/to/root/file.root")
  d_tree = rfut.get_trees_from_file(ifile)
  ```

  The following lines will create a `file.txt` with the contents of `file.root`, the text file will be in the same location as the
  ROOT file.
  ```python
  from dmu.rfile.rfprinter import RFPrinter
  obj = RFPrinter(path='/path/to/file.root')
  obj.save()
  ```

  This is mostly needed from the command line and can be done with:
  ```bash
  print_trees -p /path/to/file.root
  ```
  which would produce a `/pat/to/file.txt` file with the contents, which would look like:
  ```
  Directory/Treename
      B_CHI2                        Double_t
      B_CHI2DOF                     Double_t
      B_DIRA_OWNPV                  Float_t
      B_ENDVERTEX_CHI2              Double_t
      B_ENDVERTEX_CHI2DOF           Double_t
  ```

  Given two ROOT files the command below:
  ```bash
  compare_root_files -f file_1.root file_2.root
  ```
  will check if:
  1. The files have the same trees. If not it will print which files are in the first file but not in the second
  and vice versa.
  1. The trees have the same branches. The same checks as above will be carried out here.
  1. The branches of the corresponding trees have the same values.
  the output will also go to a `summary.yaml` file that will look like:
  ```yaml
  'Branches that differ for tree: Hlt2RD_BToMuE/DecayTree':
    - L2_BREMHYPOENERGY
    - L2_ECALPIDMU
    - L1_IS_NOT_H
  'Branches that differ for tree: Hlt2RD_LbToLMuMu_LL/DecayTree':
    - P_CaloNeutralHcal2EcalEnergyRatio
    - P_BREMENERGY
    - Pi_IS_NOT_H
    - P_BREMPIDE
  Trees only in file_1.root: []
  Trees only in file_2.root:
    - Hlt2RD_BuToKpEE_MVA_misid/DecayTree
    - Hlt2RD_BsToPhiMuMu_MVA/DecayTree
  ```


  Run:
  ```bash
  transform_text -i ./transform.txt -c ./transform.toml
  ```
  to apply a transformation to `transform.txt` following the transformations in `transform.toml`.
  The tool can be imported from another file like:
  ```python
  from dmu.text.transformer import transformer as txt_trf
  trf=txt_trf(txt_path=data.txt, cfg_path=data.cfg)
  trf.save_as(out_path=data.out)
  ```
  Currently the supported transformations are:

  Which will apppend to a given line a set of lines, the config lines could look like:
  ```toml
  [settings]
  as_substring=true
  format      ='--> {} <--'
  [append]
  'primes are'=['2', '3', '5']
  'days are'=['Monday', 'Tuesday', 'Wednesday']
  ```
  `as_substring` is a flag that will allow matches if the line in the text file only contains the key in the config
  e.g.:
  ```
  the
  first
  primes are:
  and
  the first
  days are:
  ```
  `format` will format the lines to be inserted, e.g.:
  ```
  the
  first
  primes are:
  --> 2 <--
  --> 3 <--
  --> 5 <--
  and
  the first
  days are:
  --> Monday <--
  --> Tuesday <--
  --> Wednesday <--
  ```

  Utility used to edit SSH connection list, has the following behavior:
  ```bash

  coned -p

  coned -a server_name server_index task

  coned -d server_name server_index task
  ```
  the list of servers with tasks and machines is specified in a YAML file that can look like:
  ```yaml
  ihep:
      '001' :
          - checks
          - extractor
          - dsmanager
          - classifier
      '002' :
          - checks
          - hqm2
          - dotfiles
          - data_checks
      '003' :
          - setup
          - ntupling
          - preselection
      '004' :
          - scripts
          - tools
          - dmu
          - ap
  lxplus:
      '984' :
          - ap
  ```
  and should be placed in `$HOME/.config/dmu/ssh/servers.yaml`


pkgId: 3163764591f72901caf5777c3853be72c01b9432c1ba578388d9888c89e03edc
name: python-data-repo-client-help
arch: noarch
version: 2.199.0
epoch: 0
release: 1
summary: Development documents and examples for data-repo-client
url: https://pypi.org/project/data-repo-client/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-data-repo-client-2.199.0-1.src.rpm
location_href: Packages/python-data-repo-client-help-2.199.0-1.noarch.rpm
checksum_type: sha256
description:
      &lt;details&gt;&lt;summary&gt;This document defines the REST API for the Terra Data Repository.&lt;/summary&gt; &lt;p&gt; **Status: design in progress** There are a few top-level endpoints (besides some used by swagger):  * / - generated by swagger: swagger API page that provides this documentation and a live UI for submitting REST requests  * /status - provides the operational status of the service  * /configuration - provides the basic configuration and information about the service  * /api - is the authenticated and authorized Data Repository API  * /ga4gh/drs/v1 - is a transcription of the Data Repository Service API  The API endpoints are organized by interface. Each interface is separately versioned. &lt;p&gt; **Notes on Naming** &lt;p&gt; All of the reference items are suffixed with \\&quot;Model\\&quot;. Those names are used as the class names in the generated Java code. It is helpful to distinguish these model classes from other related classes, like the DAO classes and the operation classes. &lt;/details&gt;   # noqa: E501


pkgId: fc9ba56ba1a84d999a33a1e4112e8800d22c2b9773be64ae58a609e0eb88b7c6
name: python-data2rdf-help
arch: noarch
version: 2.3.0
epoch: 0
release: 1
summary: Development documents and examples for data2rdf
url: https://github.com/MI-FraunhoferIWM/data2rdf
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-data2rdf-2.3.0-1.src.rpm
location_href: Packages/python-data2rdf-help-2.3.0-1.noarch.rpm
checksum_type: sha256
description:
  A pipeline for generating data representation in RDF out of raw data given in ASCII, CSV, JSON or EXCEL format.

  https://data2rdf.readthedocs.io/en/latest/

  <!-- Pytest Coverage Comment:Begin -->
  <a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/README.md"><img alt="Coverage" src="https://img.shields.io/badge/Coverage-88%25-green.svg" /></a><details><summary>Coverage Report </summary><table><tr><th>File</th><th>Stmts</th><th>Miss</th><th>Cover</th><th>Missing</th></tr><tbody><tr><td colspan="5"><b>data2rdf</b></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/__init__.py">__init__.py</a></td><td>5</td><td>0</td><td>100%</td><td>&nbsp;</td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/config.py">config.py</a></td><td>26</td><td>1</td><td>1</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/config.py#L 96%"> 96%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/utils.py">utils.py</a></td><td>8</td><td>1</td><td>1</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/utils.py#L 88%"> 88%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/warnings.py">warnings.py</a></td><td>2</td><td>0</td><td>100%</td><td>&nbsp;</td></tr><tr><td colspan="5"><b>data2rdf/models</b></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/__init__.py">__init__.py</a></td><td>3</td><td>0</td><td>100%</td><td>&nbsp;</td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/base.py">base.py</a></td><td>54</td><td>5</td><td>5</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/base.py#L 91%"> 91%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/graph.py">graph.py</a></td><td>119</td><td>7</td><td>7</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/graph.py#L 94%"> 94%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/mapping.py">mapping.py</a></td><td>45</td><td>1</td><td>1</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/mapping.py#L 98%"> 98%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/utils.py">utils.py</a></td><td>58</td><td>14</td><td>14</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/utils.py#L 76%"> 76%</a></td></tr><tr><td colspan="5"><b>data2rdf/modes</b></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/modes/__init__.py">__init__.py</a></td><td>4</td><td>0</td><td>100%</td><td>&nbsp;</td></tr><tr><td colspan="5"><b>data2rdf/parsers</b></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/__init__.py">__init__.py</a></td><td>6</td><td>0</td><td>100%</td><td>&nbsp;</td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/base.py">base.py</a></td><td>135</td><td>11</td><td>11</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/base.py#L 92%"> 92%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/csv.py">csv.py</a></td><td>168</td><td>20</td><td>20</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/csv.py#L 88%"> 88%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/excel.py">excel.py</a></td><td>183</td><td>17</td><td>17</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/excel.py#L 91%"> 91%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/json.py">json.py</a></td><td>216</td><td>37</td><td>37</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/json.py#L 83%"> 83%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/utils.py">utils.py</a></td><td>90</td><td>10</td><td>10</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/utils.py#L 89%"> 89%</a></td></tr><tr><td colspan="5"><b>data2rdf/pipelines</b></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/pipelines/__init__.py">__init__.py</a></td><td>2</td><td>0</td><td>100%</td><td>&nbsp;</td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/pipelines/main.py">main.py</a></td><td>82</td><td>9</td><td>9</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/pipelines/main.py#L 89%"> 89%</a></td></tr><tr><td colspan="5"><b>data2rdf/qudt</b></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/qudt/__init__.py">__init__.py</a></td><td>0</td><td>0</td><td>100%</td><td>&nbsp;</td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/qudt/utils.py">utils.py</a></td><td>42</td><td>12</td><td>12</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/qudt/utils.py#L 71%"> 71%</a></td></tr><tr><td><b>TOTAL</b></td><td><b>1248</b></td><td><b>145</b></td><td><b>88%</b></td><td>&nbsp;</td></tr></tbody></table></details>
  <!-- Pytest Coverage Comment:End -->





  Either install the package from the pypi

  ```bash
  pip install data2rdf
  ```



  Install the package from the source code:
  ```bash
  git clone git@github.com:MI-FraunhoferIWM/data2rdf.git
  cd data2rdf
  pip install -e .
  ```



  Before running the unit tests, please install the needed packages:

  ```{bash}
  pip install data2rdf[tests]
  ```

  Afterwards, run the unittest with:

  ```{bash}
  pytest
  ```




  A server will start, generate the docs and listen for changes in the source files.
  This can be done by using docker or installing the development environment directly on the you machine. Next are installation guides for Docker and Linux OS.



  First, build the Docker image by running the following command:

  ```shell
  $ docker build -f docs.Dockerfile -t data2rdf-docs .
  ```

  Then, start the program by running:

  ```shell
  $ docker run -it --rm -v $PWD:/app -p 8000:8000 data2rdf-docs
  ```



  At an OS level (these commands work on Linux Debian):

  ```shell
  $ sudo apt install pandoc graphviz default-jre
  $ sudo apt-get install texlive-latex-recommended \
                         texlive-latex-extra \
                         texlive-fonts-recommended \
                         latexmk
  ```

  The python dependencies:

  ```shell
  $ pip install .[docs]
  ```

  Now you can start the server and render the docs:

  ```
  $ sphinx-autobuild docs/source docs/build/html
  ```

  The documentation will be available on [`http://127.0.0.1:8000`](http://127.0.0.1:8000).



  To generate a PDF of the documentation, simply run (from the root project folder):

  ```sh
  make -C docs latexpdf
  ```

  The generated PDF can be found under docs/build/latex/data2rdf_docs.pdf


pkgId: c2ae8b9b047762fd00dbc65b664813997a769976efc4b7042bf07299e6e2ec6d
name: python-database-testing-tools-help
arch: noarch
version: 1.0.5
epoch: 0
release: 1
summary: Development documents and examples for database-testing-tools
url: https://github.com/moj-analytical-services/database-testing-tools
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-database-testing-tools-1.0.5-1.src.rpm
location_href: Packages/python-database-testing-tools-help-1.0.5-1.noarch.rpm
checksum_type: sha256
description:
  Database Testing Tools comprises a suite of generalised tests to run on your database, and produce reports for a notebook. It is designed for pre-production checks for curated databases, but can also be useful for monitoring changes over time. It can be particularly useful when combined with [papermill](https://papermill.readthedocs.io/en/latest/), which can be used to parameterize, execute and store notebooks as part of your pipeline.



  ```bash
  pip install database_testing_tools
  ```



  The package implements a `Tester` class, from which you can invoke a number of built-in tests and optional plotting features.

  ```python
  from database_testing_tools import Tester
  test = Tester()
  database = "my_database_name"
  out = test.check_all_tables_return_data(db_name=database)
  ```

  Tests return two outputs: the result of the test; and some nice graphical representation of the test - either a markdown table, or a plot using the [Altair](https://altair-viz.github.io/index.html) plotting library.

  The class also collects the results of the tests for an overall report, which you can access with the `Tester.get_results_table()` function.

  You can find [a notebook](https://github.com/moj-analytical-services/database-testing-tools/blob/main/tests/functions_demo_template.ipynb) which demonstrates the functions available in the package.



  The tests in this package assume the database being tested is versioned in one of two ways:
  1. [Slowly Changing Dimensions type 2 (SCD2)](https://en.wikipedia.org/wiki/Slowly_changing_dimension#Type_2:_add_new_row): where the database includes records of inserts and updates to records. In curated databases a start time and end time will be added to each record. The start time is when the record is either created or last updated; the end time is either when the record was next updated, or a date arbitrarily far in the future to signify that it is the current version of the record. By filtering on these dates, it is possible to view the state of the database at a given point in time.
  2. Snapshots: when SCD2 isn't possible or is impractical, versions of the database are recorded with an associated snapshot date based on date of extraction.

  These methods require different methods to compare versions of the database over time, so there are some separate functions to handle them in their own way.


  By default, the package uses [pydbtools](https://github.com/moj-analytical-services/pydbtools) to run the queries in the package on a given Amazon Athena database. However, it is possible to connect to your own database by making an extension of the BaseQueryEngine class defined in [utils.py](https://github.com/moj-analytical-services/database-testing-tools/blob/main/database_testing_tools/utils.py).

  An engine for [DuckDB](https://duckdb.org) is included, and is used for the demo and unit tests in this package. A basic use of the DuckDB engine looks like this:

  ```python
  import duckdb
  from database_testing_tools.utils import DuckDbEngine
  from database_testing_tools import Tester

  conn = duckdb.connect()
  query_engine = DuckDbEngine(conn)
  tester = Tester(query_engine=query_engine)
  database = "some_database"

  tester.check_all_tables_return_data(db_name=database)
  ```

  Alternative database engines should follow a similar pattern to the DuckDB engine - an initialiser that includes the database connection object, and an implementation of the `run_query` function that runs a given SQL query and returns the result as a pandas dataframe. As the built-in tests use [the Trino SQL dialect](https://trino.io/docs/current/), it is recommended to transpile the SQL with [sqlglot](https://sqlglot.com/sqlglot.html) to ensure the tests are executed correctly.


pkgId: a5aecd4a307ea4e8fd73128c79ddb202847366b5cf9036babccd964cf95b2175
name: python-databento-help
arch: noarch
version: 0.47.0
epoch: 0
release: 1
summary: Development documents and examples for databento
url: https://databento.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-databento-0.47.0-1.src.rpm
location_href: Packages/python-databento-help-0.47.0-1.noarch.rpm
checksum_type: sha256
description:
  [![test](https://github.com/databento/databento-python/actions/workflows/test.yml/badge.svg?branch=dev)](https://github.com/databento/databento-python/actions/workflows/test.yml)
  ![python](https://img.shields.io/badge/python-3.9+-blue.svg)
  [![pypi-version](https://img.shields.io/pypi/v/databento)](https://pypi.org/project/databento)
  [![license](https://img.shields.io/github/license/databento/databento-python?color=blue)](./LICENSE)
  [![code-style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Slack](https://img.shields.io/badge/join_Slack-community-darkblue.svg?logo=slack)](https://to.dbn.to/slack)

  The official Python client library for [Databento](https://databento.com).

  Key features include:
  - Fast, lightweight access to both live and historical data from [multiple markets](https://databento.com/docs/faqs/venues-and-publishers).
  - [Multiple schemas](https://databento.com/docs/schemas-and-data-formats/whats-a-schema?historical=python&live=python) such as MBO, MBP, top of book, OHLCV, last sale, and more.
  - [Fully normalized](https://databento.com/docs/standards-and-conventions/normalization?historical=python&live=python), i.e. identical message schemas for both live and historical data, across multiple asset classes.
  - Provides mappings between different symbology systems, including [smart symbology](https://databento.com/docs/api-reference-historical/basics/symbology?historical=python&live=python) for futures rollovers.
  - [Point-in-time]() instrument definitions, free of look-ahead bias and retroactive adjustments.
  - Reads and stores market data in an extremely efficient file format using [Databento Binary Encoding](https://databento.com/docs/standards-and-conventions/databento-binary-encoding?historical=python&live=python).
  - Event-driven [market replay](https://databento.com/docs/api-reference-historical/helpers/bento-replay?historical=python&live=python), including at high-frequency order book granularity.
  - Support for [batch download](https://databento.com/docs/faqs/streaming-vs-batch-download?historical=python&live=python) of flat files.
  - Support for [pandas](https://pandas.pydata.org/docs/), CSV, and JSON.


  The best place to begin is with our [Getting started](https://databento.com/docs/quickstart?historical=python&live=python) guide.

  You can find our full client API reference on the [Historical Reference](https://databento.com/docs/api-reference-historical?historical=python&live=python) and
  [Live Reference](https://databento.com/docs/reference-live?historical=python&live=python) sections of our documentation. See also the
  [Examples](https://databento.com/docs/examples?historical=python&live=python) section for various tutorials and code samples.


  The library is fully compatible with the latest distribution of Anaconda 3.9 and above.
  The minimum dependencies as found in the `pyproject.toml` are also listed below:
  - python = "^3.9"
  - aiohttp = "^3.8.3"
  - databento-dbn = "0.25.0"
  - numpy= ">=1.23.5"
  - pandas = ">=1.5.3"
  - pip-system-certs = ">=4.0" (Windows only)
  - pyarrow = ">=13.0.0"
  - requests = ">=2.25.1"
  - zstandard = ">=0.21.0"


  To install the latest stable version of the package from PyPI:

      pip install -U databento


  The library needs to be configured with an API key from your account.
  [Sign up](https://databento.com/signup) for free and you will automatically
  receive a set of API keys to start with. Each API key is a 32-character
  string starting with `db-`, that can be found on the API Keys page of your [Databento user portal](https://databento.com/platform/keys).

  A simple Databento application looks like this:

  ```python
  import databento as db

  client = db.Historical('YOUR_API_KEY')
  data = client.timeseries.get_range(
      dataset='GLBX.MDP3',
      symbols='ES.FUT',
      stype_in='parent',
      start='2022-06-10T14:30',
      end='2022-06-10T14:40',
  )

  data.replay(callback=print)  # market replay, with `print` as event handler
  ```

  Replace `YOUR_API_KEY` with an actual API key, then run this program.

  This uses `.replay()` to access the entire block of data
  and dispatch each data event to an event handler. You can also use
  `.to_df()` or `.to_ndarray()` to cast the data into a Pandas `DataFrame` or numpy `ndarray`:

  ```python
  df = data.to_df()  # to DataFrame
  array = data.to_ndarray()  # to ndarray
  ```

  Note that the API key was also passed as a parameter, which is
  [not recommended for production applications](https://databento.com/docs/portal/api-keys?historical=python&live=python).
  Instead, you can leave out this parameter to pass your API key via the `DATABENTO_API_KEY` environment variable:

  ```python
  import databento as db


  client = db.Historical('YOUR_API_KEY')


  client = db.Historical()
  ```


  Distributed under the [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0.html).


pkgId: ec4acd5a430aca111fe4898ae34b3d0fe9fc68520ac3d12d1f65dad06cdb7ea6
name: python-databpy-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for databpy
url: https://bradyajohnston.github.io/databpy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-databpy-0.0.2-1.src.rpm
location_href: Packages/python-databpy-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/BradyAJohnston/databpy/graph/badge.svg?token=KFuu67hzAz)](https://codecov.io/gh/BradyAJohnston/databpy)
  ![PyPI - Version](https://img.shields.io/pypi/v/databpy.png) ![example
  workflow](https://github.com/bradyajohnston/databpy/actions/workflows/tests.yml/badge.svg)
  ![example
  workflow](https://github.com/bradyajohnston/databpy/actions/workflows/ci-cd.yml/badge.svg)

  A set of data-oriented wrappers around the python API of Blender.



  Available on PyPI, install with pip:

  ``` bash
  pip install databpy
  ```



  The main use cases are to create objects, store and retrieve attributes
  from them. The functions are named around nodes in Geometry Nodes
  `Store Named Attribute` and `Named Attribute`

  ``` python
  import databpy as db

  db.store_named_attribute() # store a named attribute on a mesh object
  db.named_attribute()       # retrieve a named attribute from a mesh object
  ```

  Mostly oriented around creating mesh objects, assigning and getting back
  attributes from them. Currently designed around storing and retrieving
  `numpy` data types:

  ``` python
  import numpy as np
  import databpy as db



  random_verts = np.random.rand(10, 3)

  obj = db.create_object(random_verts, name="RandomMesh")

  obj.name
  ```

      'RandomMesh.001'

  ``` python
  db.named_attribute(obj, 'position')
  ```

      array([[0.17452642, 0.45645952, 0.19546226],
             [0.81541622, 0.39680132, 0.87869591],
             [0.92496204, 0.16035524, 0.97199863],
             [0.34075448, 0.5464862 , 0.02298789],
             [0.0192579 , 0.35214618, 0.56019056],
             [0.49805972, 0.46989357, 0.15057611],
             [0.98557359, 0.7825923 , 0.40234712],
             [0.1231764 , 0.33543932, 0.66668808],
             [0.85444725, 0.76267177, 0.93717819],
             [0.37655553, 0.65764296, 0.72231734]])

  This is a convenience class that wraps around the `bpy.types.Object`,
  and provides access to all of the useful functions. We can wrap an
  existing Object or return one when creating a new object.

  This just gives us access to the `named_attribute()` and
  `store_named_attribute()` functions on the object class, but also
  provides a more intuitive way to access the object’s attributes.

  ``` python
  bob = db.BlenderObject(obj)       # wraps the existing object
  bob = db.create_bob(random_verts) # creates a new object and returns it already wrapped


  bob.named_attribute('position')
  bob.position
  ```

      array([[0.17452642, 0.45645952, 0.19546226],
             [0.81541622, 0.39680132, 0.87869591],
             [0.92496204, 0.16035524, 0.97199863],
             [0.34075448, 0.5464862 , 0.02298789],
             [0.0192579 , 0.35214618, 0.56019056],
             [0.49805972, 0.46989357, 0.15057611],
             [0.98557359, 0.7825923 , 0.40234712],
             [0.1231764 , 0.33543932, 0.66668808],
             [0.85444725, 0.76267177, 0.93717819],
             [0.37655553, 0.65764296, 0.72231734]])

  We can clear all of the data from the object and initialise a new mesh
  underneath:

  ``` python
  bob.new_from_pydata(np.random.randn(5, 3))
  bob.position
  ```

      array([[ 1.30187321, -0.8981759 , -0.24894828],
             [ 0.0452443 ,  0.66260809,  0.02360807],
             [-0.04097848, -0.16771786,  3.13003659],
             [-0.85789645, -0.51301759,  0.31468081],
             [ 0.86041909, -0.50534254,  0.36779848]])


pkgId: 3a132f9e83fc162c85e662e7262ea2bffbc3d17e4f6616259b58b11bb4151ac8
name: python-databpy-help
arch: noarch
version: 0.0.4
epoch: 0
release: 1
summary: Development documents and examples for databpy
url: https://bradyajohnston.github.io/databpy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-databpy-0.0.4-1.src.rpm
location_href: Packages/python-databpy-help-0.0.4-1.noarch.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/BradyAJohnston/databpy/graph/badge.svg?token=KFuu67hzAz)](https://codecov.io/gh/BradyAJohnston/databpy)
  [![pypi](https://img.shields.io/pypi/v/databpy.png)](https://pypi.org/project/databpy/)
  ![tests](https://github.com/bradyajohnston/databpy/actions/workflows/tests.yml/badge.svg)
  ![deployment](https://github.com/bradyajohnston/databpy/actions/workflows/ci-cd.yml/badge.svg)

  A set of data-oriented wrappers around the python API of Blender.



  Available on PyPI, install with pip:

  ``` bash
  pip install databpy
  ```

  > [!CAUTION]
  >
  > `bpy` (Blender as a python module) is listed as an optional
  > dependency, so that if you install `databpy` inside of Blender you
  > won’t install a redundant version of `bpy`. If you are using this
  > outside of Blender, you will need to specifically request `bpy` with
  > either of these methods:
  >
  > ``` bash
  > # install wtih bpy dependency
  > pip install 'databpy[bpy]'
  >
  > # install both packages
  > pip install databpy bpy
  >
  > # install with all optional dependencies
  > pip install 'databpy[all]'
  > ```



  The main use cases are to create objects, store and retrieve attributes
  from them. The functions are named around nodes in Geometry Nodes
  `Store Named Attribute` and `Named Attribute`

  ``` python
  import databpy as db

  db.store_named_attribute() # store a named attribute on a mesh object
  db.named_attribute()       # retrieve a named attribute from a mesh object
  ```

  Mostly oriented around creating mesh objects, assigning and getting back
  attributes from them. Currently designed around storing and retrieving
  `numpy` data types:

  ``` python
  import numpy as np
  import databpy as db
  np.random.seed(6)


  random_verts = np.random.rand(10, 3)

  obj = db.create_object(random_verts, name="RandomMesh")

  obj.name
  ```

      'RandomMesh'

  Access attributes from the object’s mesh.

  ``` python
  db.named_attribute(obj, 'position')
  ```

      array([[0.89286017, 0.33197981, 0.8212291 ],
             [0.04169663, 0.10765668, 0.59505206],
             [0.52981734, 0.41880742, 0.33540785],
             [0.62251943, 0.43814144, 0.7358821 ],
             [0.51803643, 0.57885861, 0.64535511],
             [0.99022424, 0.81985819, 0.41320094],
             [0.87626767, 0.82375944, 0.05447451],
             [0.71863723, 0.80217057, 0.73640662],
             [0.70913178, 0.54093683, 0.12482417],
             [0.95764732, 0.4032563 , 0.21695116]])



  This is a convenience class that wraps around the `bpy.types.Object`,
  and provides access to all of the useful functions. We can wrap an
  existing Object or return one when creating a new object.

  This just gives us access to the `named_attribute()` and
  `store_named_attribute()` functions on the object class, but also
  provides a more intuitive way to access the object’s attributes.

  ``` python
  bob = db.BlenderObject(obj)       # wraps the existing object
  bob = db.create_bob(random_verts) # creates a new object and returns it already wrapped


  bob.named_attribute('position')
  bob.position
  ```

      array([[0.89286017, 0.33197981, 0.8212291 ],
             [0.04169663, 0.10765668, 0.59505206],
             [0.52981734, 0.41880742, 0.33540785],
             [0.62251943, 0.43814144, 0.7358821 ],
             [0.51803643, 0.57885861, 0.64535511],
             [0.99022424, 0.81985819, 0.41320094],
             [0.87626767, 0.82375944, 0.05447451],
             [0.71863723, 0.80217057, 0.73640662],
             [0.70913178, 0.54093683, 0.12482417],
             [0.95764732, 0.4032563 , 0.21695116]])

  We can clear all of the data from the object and initialise a new mesh
  underneath:

  ``` python
  bob.new_from_pydata(np.random.randn(5, 3))
  bob.position
  ```

      array([[ 0.82465386, -1.17643154,  1.5644896 ],
             [ 0.71270508, -0.1810066 ,  0.53419954],
             [-0.58661294, -1.48185325,  0.85724759],
             [ 0.94309896,  0.11444143, -0.02195668],
             [-2.12714458, -0.83440745, -0.46550831]])



  ``` python
  import polars as pl
  import databpy as db
  from io import StringIO

  json_file = StringIO("""
  {
    "Dino": [
      [55.3846, 97.1795, 0.0],
      [51.5385, 96.0256, 0.0]
    ],
    "Star": [
      [58.2136, 91.8819, 0.0],
      [58.1961, 92.215, 0.0]
    ]
  }
  """)

  df = pl.read_json(json_file)
  columns_to_explode = [col for col in df.columns if df[col].dtype == pl.List(pl.List)]
  df = df.explode(columns_to_explode)

  vertices = np.zeros((len(df), 3), dtype=np.float32)
  bob = db.create_bob(vertices, name="DinoStar")

  for col in df.columns:
      data = np.vstack(df.get_column(col).to_numpy())
      bob.store_named_attribute(data, col)

  bob.named_attribute("Dino")
  ```

      array([[55.38460159, 97.17949677,  0.        ],
             [51.53850174, 96.02559662,  0.        ]])

  ``` python
  bob.named_attribute("Star")
  ```

      array([[58.21360016, 91.88189697,  0.        ],
             [58.19609833, 92.21499634,  0.        ]])


pkgId: 3aa229f731879d712c45f028d25b31948781ef3dbf0106366690c88b248b49e8
name: python-databricks-sdk-help
arch: noarch
version: 0.40.0
epoch: 0
release: 1
summary: Development documents and examples for databricks-sdk
url: https://databricks-sdk-py.readthedocs.io
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-databricks-sdk-0.40.0-1.src.rpm
location_href: Packages/python-databricks-sdk-help-0.40.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - Downloads](https://img.shields.io/pypi/dw/databricks-sdk)](https://pypistats.org/packages/databricks-sdk)
  [![PyPI - License](https://img.shields.io/pypi/l/databricks-sdk)](https://github.com/databricks/databricks-sdk-py/blob/main/LICENSE)
  [![databricks-sdk](https://snyk.io/advisor/python/databricks-sdk/badge.svg)](https://snyk.io/advisor/python/databricks-sdk)
  ![PyPI](https://img.shields.io/pypi/v/databricks-sdk)
  [![codecov](https://codecov.io/gh/databricks/databricks-sdk-py/branch/main/graph/badge.svg?token=GU63K7WDBE)](https://codecov.io/gh/databricks/databricks-sdk-py)
  [![lines of code](https://tokei.rs/b1/github/databricks/databricks-sdk-py)]([https://codecov.io/github/databricks/databricks-sdk-py](https://github.com/databricks/databricks-sdk-py))

  [Beta](https://docs.databricks.com/release-notes/release-types.html): This SDK is supported for production use cases,
  but we do expect future releases to have some interface changes; see [Interface stability](#interface-stability).
  We are keen to hear feedback from you on these SDKs. Please [file issues](https://github.com/databricks/databricks-sdk-py/issues), and we will address them.
  | See also the [SDK for Java](https://github.com/databricks/databricks-sdk-java)
  | See also the [SDK for Go](https://github.com/databricks/databricks-sdk-go)
  | See also the [Terraform Provider](https://github.com/databricks/terraform-provider-databricks)
  | See also cloud-specific docs ([AWS](https://docs.databricks.com/dev-tools/sdk-python.html),
     [Azure](https://learn.microsoft.com/en-us/azure/databricks/dev-tools/sdk-python),
     [GCP](https://docs.gcp.databricks.com/dev-tools/sdk-python.html))
  | See also the [API reference on readthedocs](https://databricks-sdk-py.readthedocs.io/en/latest/)

  The Databricks SDK for Python includes functionality to accelerate development with [Python](https://www.python.org/) for the Databricks Lakehouse.
  It covers all public [Databricks REST API](https://docs.databricks.com/dev-tools/api/index.html) operations.
  The SDK's internal HTTP client is robust and handles failures on different levels by performing intelligent retries.



  - [Getting started](#getting-started)
  - [Code examples](#code-examples)
  - [Authentication](#authentication)
  - [Long-running operations](#long-running-operations)
  - [Paginated responses](#paginated-responses)
  - [Single-sign-on with OAuth](#single-sign-on-sso-with-oauth)
  - [User Agent Request Attribution](#user-agent-request-attribution)
  - [Error handling](#error-handling)
  - [Logging](#logging)
  - [Integration with `dbutils`](#interaction-with-dbutils)
  - [Interface stability](#interface-stability)



  1. Please install Databricks SDK for Python via `pip install databricks-sdk` and instantiate `WorkspaceClient`:

  ```python
  from databricks.sdk import WorkspaceClient
  w = WorkspaceClient()
  for c in w.clusters.list():
      print(c.cluster_name)
  ```

  Databricks SDK for Python is compatible with Python 3.7 _(until [June 2023](https://devguide.python.org/versions/))_, 3.8, 3.9, 3.10, and 3.11.
  **Note:** Databricks Runtime starting from version 13.1 includes a bundled version of the Python SDK.
  It is highly recommended to upgrade to the latest version which you can do by running the following in a notebook cell:

  ```python
  %pip install --upgrade databricks-sdk
  ```
  followed by
  ```python
  dbutils.library.restartPython()
  ```


  The Databricks SDK for Python comes with a number of examples demonstrating how to use the library for various common use-cases, including

  * [Using the SDK with OAuth from a webserver](https://github.com/databricks/databricks-sdk-py/blob/main/examples/flask_app_with_oauth.py)
  * [Using long-running operations](https://github.com/databricks/databricks-sdk-py/blob/main/examples/starting_job_and_waiting.py)
  * [Authenticating a client app using OAuth](https://github.com/databricks/databricks-sdk-py/blob/main/examples/local_browser_oauth.py)

  These examples and more are located in the [`examples/` directory of the Github repository](https://github.com/databricks/databricks-sdk-py/tree/main/examples).

  Some other examples of using the SDK include:
  * [Unity Catalog Automated Migration](https://github.com/databricks/ucx) heavily relies on Python SDK for working with Databricks APIs.
  * [ip-access-list-analyzer](https://github.com/alexott/databricks-playground/tree/main/ip-access-list-analyzer) checks & prunes invalid entries from IP Access Lists.



  If you use Databricks [configuration profiles](https://docs.databricks.com/dev-tools/auth.html#configuration-profiles)
  or Databricks-specific [environment variables](https://docs.databricks.com/dev-tools/auth.html#environment-variables)
  for [Databricks authentication](https://docs.databricks.com/dev-tools/auth.html), the only code required to start
  working with a Databricks workspace is the following code snippet, which instructs the Databricks SDK for Python to use
  its [default authentication flow](#default-authentication-flow):

  ```python
  from databricks.sdk import WorkspaceClient
  w = WorkspaceClient()
  w. # press <TAB> for autocompletion
  ```

  The conventional name for the variable that holds the workspace-level client of the Databricks SDK for Python is `w`, which is shorthand for `workspace`.



  - [Default authentication flow](#default-authentication-flow)
  - [Databricks native authentication](#databricks-native-authentication)
  - [Azure native authentication](#azure-native-authentication)
  - [Overriding .databrickscfg](#overriding-databrickscfg)
  - [Additional authentication configuration options](#additional-authentication-configuration-options)



  If you run the [Databricks Terraform Provider](https://registry.terraform.io/providers/databrickslabs/databricks/latest),
  the [Databricks SDK for Go](https://github.com/databricks/databricks-sdk-go), the [Databricks CLI](https://docs.databricks.com/dev-tools/cli/index.html),
  or applications that target the Databricks SDKs for other languages, most likely they will all interoperate nicely together.
  By default, the Databricks SDK for Python tries the following [authentication](https://docs.databricks.com/dev-tools/auth.html) methods,
  in the following order, until it succeeds:

  1. [Databricks native authentication](#databricks-native-authentication)
  2. [Azure native authentication](#azure-native-authentication)
  4. If the SDK is unsuccessful at this point, it returns an authentication error and stops running.

  You can instruct the Databricks SDK for Python to use a specific authentication method by setting the `auth_type` argument
  as described in the following sections.

  For each authentication method, the SDK searches for compatible authentication credentials in the following locations,
  in the following order. Once the SDK finds a compatible set of credentials that it can use, it stops searching:

  1. Credentials that are hard-coded into configuration arguments.

     :warning: **Caution**: Databricks does not recommend hard-coding credentials into arguments, as they can be exposed in plain text in version control systems. Use environment variables or configuration profiles instead.

  2. Credentials in Databricks-specific [environment variables](https://docs.databricks.com/dev-tools/auth.html#environment-variables).
  3. For Databricks native authentication, credentials in the `.databrickscfg` file's `DEFAULT` [configuration profile](https://docs.databricks.com/dev-tools/auth.html#configuration-profiles) from its default file location (`~` for Linux or macOS, and `%USERPROFILE%` for Windows).
  4. For Azure native authentication, the SDK searches for credentials through the Azure CLI as needed.

  Depending on the Databricks authentication method, the SDK uses the following information. Presented are the `WorkspaceClient` and `AccountClient` arguments (which have corresponding `.databrickscfg` file fields), their descriptions, and any corresponding environment variables.



  By default, the Databricks SDK for Python initially tries [Databricks token authentication](https://docs.databricks.com/dev-tools/api/latest/authentication.html) (`auth_type='pat'` argument). If the SDK is unsuccessful, it then tries Databricks basic (username/password) authentication (`auth_type="basic"` argument).

  - For Databricks token authentication, you must provide `host` and `token`; or their environment variable or `.databrickscfg` file field equivalents.
  - For Databricks basic authentication, you must provide `host`, `username`, and `password` _(for AWS workspace-level operations)_; or `host`, `account_id`, `username`, and `password` _(for AWS, Azure, or GCP account-level operations)_; or their environment variable or `.databrickscfg` file field equivalents.

  | Argument     | Description | Environment variable |
  |--------------|-------------|-------------------|
  | `host`       | _(String)_ The Databricks host URL for either the Databricks workspace endpoint or the Databricks accounts endpoint. | `DATABRICKS_HOST` |
  | `account_id` | _(String)_ The Databricks account ID for the Databricks accounts endpoint. Only has effect when `Host` is either `https://accounts.cloud.databricks.com/` _(AWS)_, `https://accounts.azuredatabricks.net/` _(Azure)_, or `https://accounts.gcp.databricks.com/` _(GCP)_. | `DATABRICKS_ACCOUNT_ID` |
  | `token`      | _(String)_ The Databricks personal access token (PAT) _(AWS, Azure, and GCP)_ or Azure Active Directory (Azure AD) token _(Azure)_. | `DATABRICKS_TOKEN` |
  | `username`   | _(String)_ The Databricks username part of basic authentication. Only possible when `Host` is `*.cloud.databricks.com` _(AWS)_. | `DATABRICKS_USERNAME` |
  | `password`   | _(String)_ The Databricks password part of basic authentication. Only possible when `Host` is `*.cloud.databricks.com` _(AWS)_. | `DATABRICKS_PASSWORD` |

  For example, to use Databricks token authentication:

  ```python
  from databricks.sdk import WorkspaceClient
  w = WorkspaceClient(host=input('Databricks Workspace URL: '), token=input('Token: '))
  ```



  By default, the Databricks SDK for Python first tries Azure client secret authentication (`auth_type='azure-client-secret'` argument). If the SDK is unsuccessful, it then tries Azure CLI authentication (`auth_type='azure-cli'` argument). See [Manage service principals](https://learn.microsoft.com/azure/databricks/administration-guide/users-groups/service-principals).

  The Databricks SDK for Python picks up an Azure CLI token, if you've previously authenticated as an Azure user by running `az login` on your machine. See [Get Azure AD tokens for users by using the Azure CLI](https://learn.microsoft.com/azure/databricks/dev-tools/api/latest/aad/user-aad-token).

  To authenticate as an Azure Active Directory (Azure AD) service principal, you must provide one of the following. See also [Add a service principal to your Azure Databricks account](https://learn.microsoft.com/azure/databricks/administration-guide/users-groups/service-principals#add-sp-account):

  - `azure_workspace_resource_id`, `azure_client_secret`, `azure_client_id`, and `azure_tenant_id`; or their environment variable or `.databrickscfg` file field equivalents.
  - `azure_workspace_resource_id` and `azure_use_msi`; or their environment variable or `.databrickscfg` file field equivalents.

  | Argument              | Description | Environment variable |
  |-----------------------|-------------|----------------------|
  | `azure_workspace_resource_id`   | _(String)_ The Azure Resource Manager ID for the Azure Databricks workspace, which is exchanged for a Databricks host URL. | `DATABRICKS_AZURE_RESOURCE_ID` |
  | `azure_use_msi`       | _(Boolean)_ `true` to use Azure Managed Service Identity passwordless authentication flow for service principals. _This feature is not yet implemented in the Databricks SDK for Python._ | `ARM_USE_MSI` |
  | `azure_client_secret` | _(String)_ The Azure AD service principal's client secret. | `ARM_CLIENT_SECRET` |
  | `azure_client_id`     | _(String)_ The Azure AD service principal's application ID. | `ARM_CLIENT_ID` |
  | `azure_tenant_id`     | _(String)_ The Azure AD service principal's tenant ID. | `ARM_TENANT_ID` |
  | `azure_environment`   | _(String)_ The Azure environment type (such as Public, UsGov, China, and Germany) for a specific set of API endpoints. Defaults to `PUBLIC`. | `ARM_ENVIRONMENT` |

  For example, to use Azure client secret authentication:

  ```python
  from databricks.sdk import WorkspaceClient
  w = WorkspaceClient(host=input('Databricks Workspace URL: '),
                      azure_workspace_resource_id=input('Azure Resource ID: '),
                      azure_tenant_id=input('AAD Tenant ID: '),
                      azure_client_id=input('AAD Client ID: '),
                      azure_client_secret=input('AAD Client Secret: '))
  ```

  Please see more examples in [this document](./docs/azure-ad.md).



  By default, the Databricks SDK for Python first tries GCP credentials authentication (`auth_type='google-credentials'`, argument). If the SDK is unsuccessful, it then tries Google Cloud Platform (GCP) ID authentication (`auth_type='google-id'`, argument).

  The Databricks SDK for Python picks up an OAuth token in the scope of the Google Default Application Credentials (DAC) flow. This means that if you have run `gcloud auth application-default login` on your development machine, or launch the application on the compute, that is allowed to impersonate the Google Cloud service account specified in `google_service_account`. Authentication should then work out of the box. See [Creating and managing service accounts](https://cloud.google.com/iam/docs/creating-managing-service-accounts).

  To authenticate as a Google Cloud service account, you must provide one of the following:

  - `host` and `google_credentials`; or their environment variable or `.databrickscfg` file field equivalents.
  - `host` and `google_service_account`; or their environment variable or `.databrickscfg` file field equivalents.

  | Argument                 | Description | Environment variable |
  |--------------------------|-------------|--------------------------------------------------|
  | `google_credentials`     | _(String)_ GCP Service Account Credentials JSON or the location of these credentials on the local filesystem. | `GOOGLE_CREDENTIALS` |
  | `google_service_account` | _(String)_ The Google Cloud Platform (GCP) service account e-mail used for impersonation in the Default Application Credentials Flow that does not require a password. | `DATABRICKS_GOOGLE_SERVICE_ACCOUNT` |

  For example, to use Google ID authentication:

  ```python
  from databricks.sdk import WorkspaceClient
  w = WorkspaceClient(host=input('Databricks Workspace URL: '),
                      google_service_account=input('Google Service Account: '))

  ```



  For [Databricks native authentication](#databricks-native-authentication), you can override the default behavior for using `.databrickscfg` as follows:

  | Argument      | Description | Environment variable |
  |---------------|-------------|----------------------|
  | `profile`     | _(String)_ A connection profile specified within `.databrickscfg` to use instead of `DEFAULT`. | `DATABRICKS_CONFIG_PROFILE` |
  | `config_file` | _(String)_ A non-default location of the Databricks CLI credentials file. | `DATABRICKS_CONFIG_FILE` |

  For example, to use a profile named `MYPROFILE` instead of `DEFAULT`:

  ```python
  from databricks.sdk import WorkspaceClient
  w = WorkspaceClient(profile='MYPROFILE')

  ```



  For all authentication methods, you can override the default behavior in client arguments as follows:

  | Argument                | Description | Environment variable   |
  |-------------------------|-------------|------------------------|
  | `auth_type`             | _(String)_ When multiple auth attributes are available in the environment, use the auth type specified by this argument. This argument also holds the currently selected auth. | `DATABRICKS_AUTH_TYPE` |
  | `http_timeout_seconds`  | _(Integer)_ Number of seconds for HTTP timeout. Default is _60_. | _(None)_               |
  | `retry_timeout_seconds` | _(Integer)_ Number of seconds to keep retrying HTTP requests. Default is _300 (5 minutes)_. | _(None)_               |
  | `debug_truncate_bytes`  | _(Integer)_ Truncate JSON fields in debug logs above this limit. Default is 96. | `DATABRICKS_DEBUG_TRUNCATE_BYTES` |
  | `debug_headers`         | _(Boolean)_ `true` to debug HTTP headers of requests made by the application. Default is `false`, as headers contain sensitive data, such as access tokens. | `DATABRICKS_DEBUG_HEADERS` |
  | `rate_limit`            | _(Integer)_ Maximum number of requests per second made to Databricks REST API. | `DATABRICKS_RATE_LIMIT` |

  For example, to turn on debug HTTP headers:

  ```python
  from databricks.sdk import WorkspaceClient
  w = WorkspaceClient(debug_headers=True)

  ```



  When you invoke a long-running operation, the SDK provides a high-level API to _trigger_ these operations and _wait_ for the related entities
  to reach the correct state or return the error message in case of failure. All long-running operations return generic `Wait` instance with `result()`
  method to get a result of long-running operation, once it's finished. Databricks SDK for Python picks the most reasonable default timeouts for
  every method, but sometimes you may find yourself in a situation, where you'd want to provide `datetime.timedelta()` as the value of `timeout`
  argument to `result()` method.

  There are a number of long-running operations in Databricks APIs such as managing:
  * Clusters,
  * Command execution
  * Jobs
  * Libraries
  * Delta Live Tables pipelines
  * Databricks SQL warehouses.

  For example, in the Clusters API, once you create a cluster, you receive a cluster ID, and the cluster is in the `PENDING` state Meanwhile
  Databricks takes care of provisioning virtual machines from the cloud provider in the background. The cluster is
  only usable in the `RUNNING` state and so you have to wait for that state to be reached.

  Another example is the API for running a job or repairing the run: right after
  the run starts, the run is in the `PENDING` state. The job is only considered to be finished when it is in either
  the `TERMINATED` or `SKIPPED` state. Also you would likely need the error message if the long-running
  operation times out and fails with an error code. Other times you may want to configure a custom timeout other than
  the default of 20 minutes.

  In the following example, `w.clusters.create` returns `ClusterInfo` only once the cluster is in the `RUNNING` state,
  otherwise it will timeout in 10 minutes:

  ```python
  import datetime
  import logging
  from databricks.sdk import WorkspaceClient

  w = WorkspaceClient()
  info = w.clusters.create_and_wait(cluster_name='Created cluster',
                                    spark_version='12.0.x-scala2.12',
                                    node_type_id='m5d.large',
                                    autotermination_minutes=10,
                                    num_workers=1,
                                    timeout=datetime.timedelta(minutes=10))
  logging.info(f'Created: {info}')
  ```

  Please look at the `examples/starting_job_and_waiting.py` for a more advanced usage:

  ```python
  import datetime
  import logging
  import time

  from databricks.sdk import WorkspaceClient
  import databricks.sdk.service.jobs as j

  w = WorkspaceClient()


  py_on_dbfs = f'/home/{w.current_user.me().user_name}/sample.py'
  with w.dbfs.open(py_on_dbfs, write=True, overwrite=True) as f:
      f.write(b'import time; time.sleep(10); print("Hello, World!")')


  waiter = w.jobs.submit(run_name=f'py-sdk-run-{time.time()}', tasks=[
      j.RunSubmitTaskSettings(
          task_key='hello_world',
          new_cluster=j.BaseClusterInfo(
              spark_version=w.clusters.select_spark_version(long_term_support=True),
              node_type_id=w.clusters.select_node_type(local_disk=True),
              num_workers=1
          ),
          spark_python_task=j.SparkPythonTask(
              python_file=f'dbfs:{py_on_dbfs}'
          ),
      )
  ])

  logging.info(f'starting to poll: {waiter.run_id}')


  def print_status(run: j.Run):
      statuses = [f'{t.task_key}: {t.state.life_cycle_state}' for t in run.tasks]
      logging.info(f'workflow intermediate status: {", ".join(statuses)}')









  run = waiter.result(timeout=datetime.timedelta(minutes=15),
                      callback=print_status)

  logging.info(f'job finished: {run.run_page_url}')
  ```



  On the platform side the Databricks APIs have different wait to deal with pagination:
  * Some APIs follow the offset-plus-limit pagination
  * Some start their offsets from 0 and some from 1
  * Some use the cursor-based iteration
  * Others just return all results in a single response

  The Databricks SDK for Python hides this  complexity
  under `Iterator[T]` abstraction, where multi-page results `yield` items. Python typing helps to auto-complete
  the individual item fields.

  ```python
  import logging
  from databricks.sdk import WorkspaceClient
  w = WorkspaceClient()
  for repo in w.repos.list():
      logging.info(f'Found repo: {repo.path}')
  ```

  Please look at the `examples/last_job_runs.py` for a more advanced usage:

  ```python
  import logging
  from collections import defaultdict
  from datetime import datetime, timezone
  from databricks.sdk import WorkspaceClient

  latest_state = {}
  all_jobs = {}
  durations = defaultdict(list)

  w = WorkspaceClient()
  for job in w.jobs.list():
      all_jobs[job.job_id] = job
      for run in w.jobs.list_runs(job_id=job.job_id, expand_tasks=False):
          durations[job.job_id].append(run.run_duration)
          if job.job_id not in latest_state:
              latest_state[job.job_id] = run
              continue
          if run.end_time < latest_state[job.job_id].end_time:
              continue
          latest_state[job.job_id] = run

  summary = []
  for job_id, run in latest_state.items():
      summary.append({
          'job_name': all_jobs[job_id].settings.name,
          'last_status': run.state.result_state,
          'last_finished': datetime.fromtimestamp(run.end_time/1000, timezone.utc),
          'average_duration': sum(durations[job_id]) / len(durations[job_id])
      })

  for line in sorted(summary, key=lambda s: s['last_finished'], reverse=True):
      logging.info(f'Latest: {line}')
  ```





  For a regular web app running on a server, it's recommended to use the Authorization Code Flow to obtain an Access Token
  and a Refresh Token. This method is considered safe because the Access Token is transmitted directly to the server
  hosting the app, without passing through the user's web browser and risking exposure.

  To enhance the security of the Authorization Code Flow, the PKCE (Proof Key for Code Exchange) mechanism can be
  employed. With PKCE, the calling application generates a secret called the Code Verifier, which is verified by
  the authorization server. The app also creates a transform value of the Code Verifier, called the Code Challenge,
  and sends it over HTTPS to obtain an Authorization Code. By intercepting the Authorization Code, a malicious attacker
  cannot exchange it for a token without possessing the Code Verifier.

  The [presented sample](https://github.com/databricks/databricks-sdk-py/blob/main/examples/flask_app_with_oauth.py)
  is a Python3 script that uses the Flask web framework along with Databricks SDK for Python to demonstrate how to
  implement the OAuth Authorization Code flow with PKCE security. It can be used to build an app where each user uses
  their identity to access Databricks resources. The script can be executed with or without client and secret credentials
  for a custom OAuth app.

  Databricks SDK for Python exposes the `oauth_client.initiate_consent()` helper to acquire user redirect URL and initiate
  PKCE state verification. Application developers are expected to persist `RefreshableCredentials` in the webapp session
  and restore it via `RefreshableCredentials.from_dict(oauth_client, session['creds'])` helpers.

  Works for both AWS and Azure. Not supported for GCP at the moment.

  ```python
  from databricks.sdk.oauth import OAuthClient

  oauth_client = OAuthClient(host='<workspace-url>',
                             client_id='<oauth client ID>',
                             redirect_url=f'http://host.domain/callback',
                             scopes=['clusters'])

  import secrets
  from flask import Flask, render_template_string, request, redirect, url_for, session

  APP_NAME = 'flask-demo'
  app = Flask(APP_NAME)
  app.secret_key = secrets.token_urlsafe(32)


  @app.route('/callback')
  def callback():
     from databricks.sdk.oauth import Consent
     consent = Consent.from_dict(oauth_client, session['consent'])
     session['creds'] = consent.exchange_callback_parameters(request.args).as_dict()
     return redirect(url_for('index'))


  @app.route('/')
  def index():
     if 'creds' not in session:
        consent = oauth_client.initiate_consent()
        session['consent'] = consent.as_dict()
        return redirect(consent.auth_url)

     from databricks.sdk import WorkspaceClient
     from databricks.sdk.oauth import SessionCredentials

     credentials_provider = SessionCredentials.from_dict(oauth_client, session['creds'])
     workspace_client = WorkspaceClient(host=oauth_client.host,
                                        product=APP_NAME,
                                        credentials_provider=credentials_provider)

     return render_template_string('...', w=workspace_client)
  ```



  For applications, that do run on developer workstations, Databricks SDK for Python provides `auth_type='external-browser'`
  utility, that opens up a browser for a user to go through SSO flow. Azure support is still in the early experimental
  stage.

  ```python
  from databricks.sdk import WorkspaceClient

  host = input('Enter Databricks host: ')

  w = WorkspaceClient(host=host, auth_type='external-browser')
  clusters = w.clusters.list()

  for cl in clusters:
      print(f' - {cl.cluster_name} is {cl.state}')
  ```



  In order to use OAuth with Databricks SDK for Python, you should use `account_client.custom_app_integration.create` API.

  ```python
  import logging, getpass
  from databricks.sdk import AccountClient
  account_client = AccountClient(host='https://accounts.cloud.databricks.com',
                                 account_id=input('Databricks Account ID: '),
                                 username=input('Username: '),
                                 password=getpass.getpass('Password: '))

  logging.info('Enrolling all published apps...')
  account_client.o_auth_enrollment.create(enable_all_published_apps=True)

  status = account_client.o_auth_enrollment.get()
  logging.info(f'Enrolled all published apps: {status}')

  custom_app = account_client.custom_app_integration.create(
      name='awesome-app',
      redirect_urls=[f'https://host.domain/path/to/callback'],
      confidential=True)
  logging.info(f'Created new custom app: '
               f'--client_id {custom_app.client_id} '
               f'--client_secret {custom_app.client_secret}')
  ```



  The Databricks SDK for Python uses the `User-Agent` header to include request metadata along with each request. By default, this includes the version of the Python SDK, the version of the Python language used by your application, and the underlying operating system. To statically add additional metadata, you can use the `with_partner()` and `with_product()` functions in the `databricks.sdk.useragent` module. `with_partner()` can be used by partners to indicate that code using the Databricks SDK for Go should be attributed to a specific partner. Multiple partners can be registered at once. Partner names can contain any number, digit, `.`, `-`, `_` or `+`.

  ```python
  from databricks.sdk import useragent
  useragent.with_product("partner-abc")
  useragent.with_partner("partner-xyz")
  ```

  `with_product()` can be used to define the name and version of the product that is built with the Databricks SDK for Python. The product name has the same restrictions as the partner name above, and the product version must be a valid [SemVer](https://semver.org/). Subsequent calls to `with_product()` replace the original product with the new user-specified one.

  ```go
  from databricks.sdk import useragent
  useragent.with_product("databricks-example-product", "1.2.0")
  ```

  If both the `DATABRICKS_SDK_UPSTREAM` and `DATABRICKS_SDK_UPSTREAM_VERSION` environment variables are defined, these will also be included in the `User-Agent` header.

  If additional metadata needs to be specified that isn't already supported by the above interfaces, you can use the `with_user_agent_extra()` function to register arbitrary key-value pairs to include in the user agent. Multiple values associated with the same key are allowed. Keys have the same restrictions as the partner name above. Values must be either as described above or SemVer strings.

  Additional `User-Agent` information can be associated with different instances of `DatabricksConfig`. To add metadata to a specific instance of `DatabricksConfig`, use the `with_user_agent_extra()` method.



  The Databricks SDK for Python provides a robust error-handling mechanism that allows developers to catch and handle API errors. When an error occurs, the SDK will raise an exception that contains information about the error, such as the HTTP status code, error message, and error details. Developers can catch these exceptions and handle them appropriately in their code.

  ```python
  from databricks.sdk import WorkspaceClient
  from databricks.sdk.errors import ResourceDoesNotExist

  w = WorkspaceClient()
  try:
      w.clusters.get(cluster_id='1234-5678-9012')
  except ResourceDoesNotExist as e:
      print(f'Cluster not found: {e}')
  ```

  The SDK handles inconsistencies in error responses amongst the different services, providing a consistent interface for developers to work with. Simply catch the appropriate exception type and handle the error as needed. The errors returned by the Databricks API are defined in [databricks/sdk/errors/platform.py](https://github.com/databricks/databricks-sdk-py/blob/main/databricks/sdk/errors/platform.py).



  The Databricks SDK for Python seamlessly integrates with the standard [Logging facility for Python](https://docs.python.org/3/library/logging.html).
  This allows developers to easily enable and customize logging for their Databricks Python projects.
  To enable debug logging in your Databricks Python project, you can follow the example below:

  ```python
  import logging, sys
  logging.basicConfig(stream=sys.stderr,
                      level=logging.INFO,
                      format='s [s][s] s')
  logging.getLogger('databricks.sdk').setLevel(logging.DEBUG)

  from databricks.sdk import WorkspaceClient
  w = WorkspaceClient(debug_truncate_bytes=1024, debug_headers=False)
  for cluster in w.clusters.list():
      logging.info(f'Found cluster: {cluster.cluster_name}')
  ```

  In the above code snippet, the logging module is imported and the `basicConfig()` method is used to set the logging level to `DEBUG`.
  This will enable logging at the debug level and above. Developers can adjust the logging level as needed to control the verbosity of the logging output.
  The SDK will log all requests and responses to standard error output, using the format `> ` for requests and `< ` for responses.
  In some cases, requests or responses may be truncated due to size considerations. If this occurs, the log message will include
  the text `... (XXX additional elements)` to indicate that the request or response has been truncated. To increase the truncation limits,
  developers can set the `debug_truncate_bytes` configuration property or the `DATABRICKS_DEBUG_TRUNCATE_BYTES` environment variable.
  To protect sensitive data, such as authentication tokens, passwords, or any HTTP headers, the SDK will automatically replace these
  values with `**REDACTED**` in the log output. Developers can disable this redaction by setting the `debug_headers` configuration property to `True`.

  ```text
  2023-03-22 21:19:21,702 [databricks.sdk][DEBUG] GET /api/2.0/clusters/list
  < 200 OK
  < {
  <   "clusters": [
  <     {
  <       "autotermination_minutes": 60,
  <       "cluster_id": "1109-115255-s1w13zjj",
  <       "cluster_name": "DEFAULT Test Cluster",
  <       ... truncated for brevity
  <     },
  <     "... (47 additional elements)"
  <   ]
  < }
  ```

  Overall, the logging capabilities provided by the Databricks SDK for Python can be a powerful tool for monitoring and troubleshooting your
  Databricks Python projects. Developers can use the various logging methods and configuration options provided by the SDK to customize
  the logging output to their specific needs.



  You can use the client-side implementation of [`dbutils`](https://docs.databricks.com/dev-tools/databricks-utils.html) by accessing `dbutils` property on the `WorkspaceClient`.
  Most of the `dbutils.fs` operations and `dbutils.secrets` are implemented natively in Python within Databricks SDK. Non-SDK implementations still require a Databricks cluster,
  that you have to specify through the `cluster_id` configuration attribute or `DATABRICKS_CLUSTER_ID` environment variable. Don't worry if cluster is not running: internally,
  Databricks SDK for Python calls `w.clusters.ensure_cluster_is_running()`.

  ```python
  from databricks.sdk import WorkspaceClient

  w = WorkspaceClient()
  dbutils = w.dbutils

  files_in_root = dbutils.fs.ls('/')
  print(f'number of files in root: {len(files_in_root)}')
  ```

  Alternatively, you can import `dbutils` from `databricks.sdk.runtime` module, but you have to make sure that all configuration is already [present in the environment variables](#default-authentication-flow):

  ```python
  from databricks.sdk.runtime import dbutils

  for secret_scope in dbutils.secrets.listScopes():
      for secret_metadata in dbutils.secrets.list(secret_scope.name):
          print(f'found {secret_metadata.key} secret in {secret_scope.name} scope')
  ```



  Databricks is actively working on stabilizing the Databricks SDK for Python's interfaces.
  API clients for all services are generated from specification files that are synchronized from the main platform.
  You are highly encouraged to pin the exact dependency version and read the [changelog](https://github.com/databricks/databricks-sdk-py/blob/main/CHANGELOG.md)
  where Databricks documents the changes. Databricks may have minor [documented](https://github.com/databricks/databricks-sdk-py/blob/main/CHANGELOG.md)
  backward-incompatible changes, such as renaming some type names to bring more consistency.


pkgId: 88b8da7ed7b27f5718ca9d6e0df1da9f0b6915ce341982fd3e0e47adecce6b3a
name: python-databridge-client-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for databridge-client
url: https://pypi.org/project/databridge-client/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-databridge-client-0.1.3-1.src.rpm
location_href: Packages/python-databridge-client-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  A Python client for DataBridge API that enables document ingestion and semantic search capabilities.



  ```bash
  pip install databridge-client
  ```

  ```python
  from databridge import DataBridge


  db = DataBridge("your-api-key")


  doc_id = await db.ingest_document(
      content="Your document content",
      metadata={"title": "Example Document"}
  )


  results = await db.query(
      query="Your search query",
      filters={"title": "Example Document"}
  )


  for result in results:
      print(f"Content: {result.content}")
      print(f"Score: {result.score}")
      print(f"Metadata: {result.metadata}")
  ```


pkgId: b9c5b8a6ee3d15c79cf746a66a4299ae54b6a115f9d49db5c7282f0115a7bdca
name: python-dataclass-dict-convert-help
arch: noarch
version: 1.7.4
epoch: 0
release: 1
summary: Development documents and examples for dataclass-dict-convert
url: https://gitlab.ilabt.imec.be/wvdemeer/dataclass-dict-convert
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dataclass-dict-convert-1.7.4-1.src.rpm
location_href: Packages/python-dataclass-dict-convert-help-1.7.4-1.noarch.rpm
checksum_type: sha256
description:
  This library converts between python [dataclasses](https://docs.python.org/3/library/dataclasses.html#dataclasses.dataclass) and dicts (and json).

  It was created because when using the [dataclasses-json](https://pypi.org/project/dataclasses-json/) library for my use case, I ran into limitations and performance issues.
  (There's also [typed-json-dataclass](https://pypi.org/project/typed-json-dataclass) but I haven't evaluated that library.)

  Since creating this library, I've discovered [Pydentic](https://pypi.org/project/pydentic/), which is a much more professional library, that in 99% of cases will be much more suitable than this library.
  So I strongly recommend using Pydentic. If you use `dataclass-dict-convert`, beware that it is poorly maintained, not very well documented, may contain some bugs, and has some strange edge cases where it doesn't work.

  `dataclass-dict-convert` supports lists, optionals, dicts, enums, nested dataclasses, etc.
  It handles dates using RFC3339 (and enforces timezones and timezone aware `datetime`).

  Example:

  ```python
  from dataclasses import dataclass
  from stringcase import camelcase
  from typing import Optional, List

  from dataclass_dict_convert import dataclass_dict_convert


  @dataclass_dict_convert(dict_letter_case=camelcase)
  @dataclass(frozen=True)
  class TestB:
      an_int: int
      a_str: str
      a_float: float
      a_bool: bool


  @dataclass_dict_convert(dict_letter_case=camelcase)
  @dataclass(frozen=True)
  class Test:
      nestedClass: TestB
      nestedInOpt: Optional[TestB]
      nestedInList: List[TestB]


  the_instanceB1 = TestB(1, 'foo', 0.1, True)
  the_instanceB2 = TestB(2, 'bar', 0.2, False)
  the_instanceB3 = TestB(3, 'baz', 0.3, True)
  the_instanceB4 = TestB(4, 'huh', 0.4, False)
  the_instance = Test(the_instanceB1, the_instanceB2, [the_instanceB3, the_instanceB4])
  the_dict = {
      'nestedClass': {'anInt': 1, 'aStr': 'foo', 'aFloat': 0.1, 'aBool': True, },
      'nestedInOpt': {'anInt': 2, 'aStr': 'bar', 'aFloat': 0.2, 'aBool': False, },
      'nestedInList': [
          {'anInt': 3, 'aStr': 'baz', 'aFloat': 0.3, 'aBool': True, },
          {'anInt': 4, 'aStr': 'huh', 'aFloat': 0.4, 'aBool': False, },
      ],
  }

  expected = the_dict
  actual = the_instance.to_dict()
  assert actual == expected

  expected = the_instance
  actual = Test.from_dict(the_dict)
  assert actual == expected
  ```

  The library also includes:
  - RFC3339 tools (the default format for converting datetime to string),
  - dataclass type checking tools
  - dataclass copy method generator
  - dataclass multiline repr (replace auto generated repr for dataclasses by a multiline version)

  Links:
  - Gitlab: https://gitlab.ilabt.imec.be/wvdemeer/dataclass-dict-convert
  - PyPi: https://pypi.org/project/dataclass-dict-convert/


pkgId: 15298700c6399acdfb493b917a83dd9b7ea6dcecc050ca5046ed5a074261bdd5
name: python-datadog-api-client-help
arch: noarch
version: 2.31.0
epoch: 0
release: 1
summary: Development documents and examples for datadog-api-client
url: https://github.com/DataDog/datadog-api-client-python
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-datadog-api-client-2.31.0-1.src.rpm
location_href: Packages/python-datadog-api-client-help-2.31.0-1.noarch.rpm
checksum_type: sha256
description:
  This repository contains a Python API client for the [Datadog API](https://docs.datadoghq.com/api/).



  Building and using the API client library requires [Python 3.7+](https://www.python.org/downloads/).



  To install the API client library, simply execute:

  ```shell
  pip install datadog-api-client
  ```



  Please follow the [installation](#installation) instruction and execute the following Python code:

  ```python
  from datadog_api_client import ApiClient, Configuration
  from datadog_api_client.v1.api.monitors_api import MonitorsApi
  from datadog_api_client.v1.model.monitor import Monitor
  from datadog_api_client.v1.model.monitor_type import MonitorType

  body = Monitor(
      name="example",
      type=MonitorType("log alert"),
      query='logs("service:foo AND type:error").index("main").rollup("count").by("source").last("5m") > 2',
      message="some message Notify: @hipchat-channel",
      tags=["test:example", "env:ci"],
      priority=3,
  )

  configuration = Configuration()
  with ApiClient(configuration) as api_client:
      api_instance = MonitorsApi(api_client)
      response = api_instance.create_monitor(body=body)
      print(response)
  ```



  By default the library will use the `DD_API_KEY` and `DD_APP_KEY` environment variables to authenticate against the Datadog API.
  To provide your own set of credentials, you need to set some keys on the configuration:

  ```python
  configuration.api_key["apiKeyAuth"] = "<API KEY>"
  configuration.api_key["appKeyAuth"] = "<APPLICATION KEY>"
  ```



  This client includes access to Datadog API endpoints while they are in an unstable state and may undergo breaking changes. An extra configuration step is required to enable these endpoints:

  ```python
  configuration.unstable_operations["<OperationName>"] = True
  ```

  where `<OperationName>` is the name of the method used to interact with that endpoint. For example: `list_log_indexes`, or `get_logs_index`



  When talking to a different server, like the `eu` instance, change the `server_variables` on your configuration object:

  ```python
  configuration.server_variables["site"] = "datadoghq.eu"
  ```



  If you want to disable GZIP compressed responses, set the `compress` flag
  on your configuration object:

  ```python
  configuration.compress = False
  ```



  If you want to enable requests logging, set the `debug` flag on your configuration object:

  ```python
  configuration.debug = True
  ```



  If you want to enable retry when getting status code `429` rate-limited, set `enable_retry` to `True`

  ```python
      configuration.enable_retry = True
  ```

  The default max retry is `3`, you can change it with `max_retries`

  ```python
      configuration.max_retries = 5
  ```



  You can configure the client to use proxy by setting the `proxy` key on configuration object:

  ```python
  configuration.proxy = "http://127.0.0.1:80"
  ```



  You can run API calls in a thread by using `ThreadedApiClient` in place of `ApiClient`. API calls will then
  return a `AsyncResult` instance on which you can call get to retrieve the result:

  ```python
  from datadog_api_client import Configuration, ThreadedApiClient
  from datadog_api_client.v1.api.dashboards_api import DashboardsApi

  configuration = Configuration()
  with ThreadedApiClient(configuration) as api_client:
      api_instance = DashboardsApi(api_client)
      result = api_instance.list_dashboards()
      dashboards = result.get()
      print(dashboards)
  ```



  The library supports asynchronous operations when using `AsyncApiClient` for the transport. When that client is used,
  the API methods will then return coroutines that you can wait for.

  To make async support available, you need to install the extra `async` qualifiers during installation: `pip install datadog-api-client[async]`.

  ```python
  import asyncio

  from datadog_api_client import Configuration, AsyncApiClient
  from datadog_api_client.v1.api.dashboards_api import DashboardsApi

  async def main():
      configuration = Configuration()
      async with AsyncApiClient(configuration) as api_client:
          api_instance = DashboardsApi(api_client)
          dashboards = await api_instance.list_dashboards()
          print(dashboards)

  asyncio.run(main())
  ```



  Several listing operations have a pagination method to help consume all the items available.
  For example, to retrieve all your incidents:

  ```python
  from datadog_api_client import ApiClient, Configuration
  from datadog_api_client.v2.api.incidents_api import IncidentsApi

  configuration = Configuration()
  configuration.unstable_operations["list_incidents"] = True
  with ApiClient(configuration) as api_client:
      api_instance = IncidentsApi(api_client)
      for incident in api_instance.list_incidents_with_pagination():
          print(incident.id)
  ```



  Documentation for API endpoints and models are available on [readthedocs](https://datadog-api-client.readthedocs.io/).



  Authenticate with the API by providing your API and Application keys in the configuration:

  ```python
  configuration.api_key["apiKeyAuth"] = "YOUR_API_KEY"
  configuration.api_key["appKeyAuth"] = "YOUR_APPLICATION_KEY"
  ```



  support@datadoghq.com


pkgId: c760833131f086c50fe0c8a9c7cdb598ec1c95484c9d10dee92d1981b84a96f7
name: python-dataeval-help
arch: noarch
version: 0.74.1
epoch: 0
release: 1
summary: Development documents and examples for dataeval
url: https://dataeval.ai/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dataeval-0.74.1-1.src.rpm
location_href: Packages/python-dataeval-help-0.74.1-1.noarch.rpm
checksum_type: sha256
description:
  DataEval focuses on characterizing image data and its impact on model performance across Classification and object-detection tasks.

  <!-- start about -->

  **Model-agnostic metrics that bound real-world performance**
  - relevance/completeness/coverage
  - metafeatures (data complexity)

  **Model-specific metrics that guide model selection and training**
  - dataset sufficiency
  - data/model complexity mismatch

  **Metrics for post-deployment monitoring of data with bounds on model performance to guide retraining**
  - dataset-shift metrics
  - model performance bounds under covariate shift
  - guidance on sampling to assess model error and model retraining

  <!-- end about -->




  - Python 3.9-3.11



  You can install DataEval directly from pypi.org using the following command.  The optional dependencies of DataEval are `torch`, `tensorflow` and `all`.  Using `torch` enables Sufficiency metrics, and `tensorflow` enables OOD Detection.

  ```
  pip install dataeval[all]
  ```



  DataEval can be installed in a Conda/Mamba environment using the provided `environment.yaml` file.  As some dependencies
  are installed from the `pytorch` channel, the channel is specified in the below example.

  ```
  micromamba create -f environment\environment.yaml -c pytorch
  ```



  To install DataEval from source locally on Ubuntu, you will need `git-lfs` to download larger, binary source files and `poetry` for project dependency management.

  ```
  sudo apt-get install git-lfs
  pip install poetry
  ```

  Pull the source down and change to the DataEval project directory.
  ```
  git clone https://github.com/aria-ml/dataeval.git
  cd dataeval
  ```



  Install DataEval with optional dependencies for development.
  ```
  poetry install --all-extras --with dev
  ```

  Now that DataEval is installed, you can run commands in the poetry virtual environment by prefixing shell commands with `poetry run`, or activate the virtual environment directly in the shell.
  ```
  poetry shell
  ```


  For more ideas on getting started using DataEval in your workflow, additional information and tutorials are in our Sphinx documentation hosted on [Read the Docs](https://dataeval.readthedocs.io/).


  This project uses code from the [Alibi-Detect](https://github.com/SeldonIO/alibi-detect) python library developed by SeldonIO.  Additional documentation from the developers are also available [here](https://docs.seldon.io/projects/alibi-detect/en/stable/).


  - **POC**: Scott Swan @scott.swan
  - **DPOC**: Andrew Weng @aweng


pkgId: 2e98d7246267742ea0bd6236bf01713d3cd248b3d598a1e6983a32de076bcbc9
name: python-dataforseo-client-help
arch: noarch
version: 1.0.39
epoch: 0
release: 1
summary: Development documents and examples for dataforseo-client
url: https://pypi.org/project/dataforseo-client/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dataforseo-client-1.0.39-1.src.rpm
location_href: Packages/python-dataforseo-client-help-1.0.39-1.noarch.rpm
checksum_type: sha256
description:
      DataForSEO API is the starting point on your journey towards building powerful SEO software. With DataForSEO you can get all the data you need to build an efficient application while also saving your time and budget. DataForSEO API is using the REST technology for interchanging data between your application and our service. The data exchange is made through the widely used HTTP protocol, which allows applying our API to almost all programming languages.


pkgId: 8191fe9d140706472a51fe031f56372eceb5ec63b57fbcc5986be705624a1242
name: python-dataframe-to-online-spreadsheet-help
arch: noarch
version: 0.1.14
epoch: 0
release: 1
summary: Development documents and examples for dataframe-to-online-spreadsheet
url: https://github.com/kafkaliu/dataframe_to_online_spreadsheet
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dataframe-to-online-spreadsheet-0.1.14-1.src.rpm
location_href: Packages/python-dataframe-to-online-spreadsheet-help-0.1.14-1.noarch.rpm
checksum_type: sha256
description:
  The online spreadsheet such as Google Sheets, Feishu Docs, is a good way to share data with others and is a powerful tool for data analysis and visualization. This package provides a simple way to export a pandas dataframe to a online spreadsheet.


  You can install this package from PyPI using pip:
  ```bash
  pip install dataframe-to-online-spreadsheet
  ```





  1. You need to register a Feishu team and get the manager_ids from [Feishu Admin](https://www.feishu.cn/). Fortunately, it is free for a small team.
  2. You need to create an app and get the app_id and app_secret from [Feishu Open Platform](https://open.feishu.cn/).

  ```python
  import pandas as pd
  import dataframe_to_online_spreadsheet.feishu
  import os

  def test_feishu():

      app_id = os.getenv("APP_ID")
      app_secret = os.getenv("APP_SECRET")

      sheet1_data = pd.read_csv("./tests/test_data1.csv")
      token = sheet1_data.feishu.to_spreadsheet(app_id, app_secret, title="Daily Report", data={'title': 'sheet_name1', 'data': sheet1_data}, manager_ids=['xxx'])

      sheet2_data = pd.read_csv("./tests/test_data2.csv")
      token = sheet2_data.feishu.to_spreadsheet(app_id, app_secret, title="Daily Report", data={'title': 'sheet_name2', 'data': sheet2_data}, manager_ids=['xxx'], spreadsheet_token=token)

      sheet3_data = pd.read_csv("./tests/test_data3.csv")
      token = sheet3_data.feishu.to_spreadsheet(app_id, app_secret, title="Daily Report", data={'title': 'sheet_name3', 'data': sheet3_data}, manager_ids=['xxx'], spreadsheet_token=token)
      logging.info(f"spreadsheet token: {token}")
      assert token
  ```



  1. You need login [Wecom Developer](https://developer.work.weixin.qq.com/).
  2. You need to create an app and get the app_id and app_secret.
  3. Create a smartsheet and get the doc_id and sheet_id.

  ```python
  import pandas as pd
  import dataframe_to_online_spreadsheet.wecom
  import os

  def test_wecom():

      app_id = os.getenv("APP_ID")
      app_secret = os.getenv("APP_SECRET")
      doc_id = os.getenv("DOC_ID")
      sheet_id = os.getenv("SHEET_ID")

      sheet1_data = pd.read_csv("./tests/test_data1_wecom.csv")

      fields_ids = {
          "f3jXlv": "FIELD_TYPE_NUMBER",
          "f8BRn6": "FIELD_TYPE_TEXT",
          "fBgV4J": "FIELD_TYPE_TEXT",
          "fD1c0G": "FIELD_TYPE_TEXT",
          "fGJwzi": "FIELD_TYPE_TEXT",
          "fMtBZy": "FIELD_TYPE_TEXT",
          "fQONOH": "FIELD_TYPE_TEXT",
          "fQQyQY": "FIELD_TYPE_DATE_TIME",
          "fRq1I2": "FIELD_TYPE_DATE_TIME",
          "fSmqgA": "FIELD_TYPE_TEXT",
          "fSu8nr": "FIELD_TYPE_NUMBER",
          "fWY1jO": "FIELD_TYPE_TEXT",
          "fYrjfz": "FIELD_TYPE_NUMBER",
          "fZH5aH": "FIELD_TYPE_TEXT",
          "fZZ5uE": "FIELD_TYPE_NUMBER",
          "fZilZm": "FIELD_TYPE_TEXT",
          "faGRO9": "FIELD_TYPE_TEXT",
          "fcIPid": "FIELD_TYPE_TEXT",
          "ffPlXC": "FIELD_TYPE_NUMBER",
          "fgxTYC": "FIELD_TYPE_TEXT",
          "fpqHBM": "FIELD_TYPE_NUMBER",
          "fwLOij": "FIELD_TYPE_TEXT",
          "fxRfyy": "FIELD_TYPE_NUMBER",
          "fzNsma": "FIELD_TYPE_TEXT",
          "fwF1k7": "FIELD_TYPE_USER",
      }
      records = sheet1_data.wecom.to_spreadsheet(
          app_id, app_secret, doc_id, sheet_id, fields_ids
      )

      logging.info(records)
      assert records
  ```


pkgId: e4d2dfebbbd6398f7cea74a3e405e0ce6d841e589b87b36f3173ea4f34f86bcb
name: python-datagrid-help
arch: noarch
version: 1.0.8
epoch: 0
release: 1
summary: Development documents and examples for datagrid
url: https://github.com/dsblank/datagrid
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-datagrid-1.0.8-1.src.rpm
location_href: Packages/python-datagrid-help-1.0.8-1.noarch.rpm
checksum_type: sha256
description:
  Create a datagrid of mixed-media items, and log to comet.com.



  ```
  pip install datagrid
  ```



  The following demo program will log 100 random images, scores, and categories:

  ```python
  from comet_ml import start
  from datagrid import DataGrid, Image

  import random
  from PIL import Image as PImage
  import requests

  experiment = start(project_name="datagrids")

  categories = ["sunset", "landscape", "water", "tree", "city"]

  dg = DataGrid(
      columns=["Image", "Score", "Category"],
      name="Demo"
  )
  url = "https://picsum.photos/200/300"
  for i in range(100):
      im = PImage.open(requests.get(url, stream=True).raw)
      category = random.choice(categories)
      score = random.random()
      image = Image(im, metadata={"category": category, "score": score})
      dg.append([image, score, category])

  dg.log(experiment)
  experiment.end()
  ```



  ![image](https://github.com/user-attachments/assets/a2a168cd-8e82-4418-b793-58e76bc5ab63)

  Log into <a href="https://comet.com">comet.com</a> to see results.


