# packages

pkgId: b237a25350f0d717d54007e7284a4ce73c46c28cadb817ad142f1bd4c1e5841d
name: python-OpenFisca-France-help
arch: noarch
version: 169.13.0
epoch: 0
release: 1
summary: Development documents and examples for OpenFisca-France
url: https://github.com/openfisca/openfisca-france
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-OpenFisca-France-169.13.0-1.src.rpm
location_href: Packages/python-OpenFisca-France-help-169.13.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Newsletter](https://img.shields.io/badge/newsletter-subscribe!-informational.svg?style=flat)](mailto:contact%40openfisca.org?subject=Subscribe%20to%20your%20newsletter%20%7C%20S'inscrire%20%C3%A0%20votre%20newsletter&body=%5BEnglish%20version%20below%5D%0A%0ABonjour%2C%0A%0AVotre%C2%A0pr%C3%A9sence%C2%A0ici%C2%A0nous%C2%A0ravit%C2%A0!%20%F0%9F%98%83%0A%0AEnvoyez-nous%20cet%20email%20pour%20que%20l'on%20puisse%20vous%20inscrire%20%C3%A0%20la%20newsletter.%20%0A%0AAh%C2%A0!%20Et%20si%20vous%20pouviez%20remplir%20ce%20petit%20questionnaire%2C%20%C3%A7a%20serait%20encore%20mieux%C2%A0!%0Ahttps%3A%2F%2Fgoo.gl%2Fforms%2F45M0VR1TYKD1RGzX2%0A%0AAmiti%C3%A9%2C%0AL%E2%80%99%C3%A9quipe%20OpenFisca%0A%0A%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%20ENGLISH%20VERSION%20%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%0A%0AHi%2C%20%0A%0AWe're%20glad%20to%20see%20you%20here!%20%F0%9F%98%83%0A%0APlease%20send%20us%20this%20email%2C%20so%20we%20can%20subscribe%20you%20to%20the%20newsletter.%0A%0AAlso%2C%20if%20you%20can%20fill%20out%20this%20short%20survey%2C%20even%20better!%0Ahttps%3A%2F%2Fgoo.gl%2Fforms%2FsOg8K1abhhm441LG2%0A%0ACheers%2C%0AThe%20OpenFisca%20Team)
  [![Twitter](https://img.shields.io/badge/twitter-follow%20us!-9cf.svg?style=flat)](https://twitter.com/intent/follow?screen_name=openfisca)
  [![Slack](https://img.shields.io/badge/slack-join%20us!-blueviolet.svg?style=flat)](mailto:contact%40openfisca.org?subject=Join%20you%20on%20Slack%20%7C%20Nous%20rejoindre%20sur%20Slack&body=%5BEnglish%20version%20below%5D%0A%0ABonjour%2C%0A%0AVotre%C2%A0pr%C3%A9sence%C2%A0ici%C2%A0nous%C2%A0ravit%C2%A0!%20%F0%9F%98%83%0A%0ARacontez-nous%20un%20peu%20de%20vous%2C%20et%20du%20pourquoi%20de%20votre%20int%C3%A9r%C3%AAt%20de%20rejoindre%20la%20communaut%C3%A9%20OpenFisca%20sur%20Slack.%0A%0AAh%C2%A0!%20Et%20si%20vous%20pouviez%20remplir%20ce%20petit%20questionnaire%2C%20%C3%A7a%20serait%20encore%20mieux%C2%A0!%0Ahttps%3A%2F%2Fgoo.gl%2Fforms%2F45M0VR1TYKD1RGzX2%0A%0AN%E2%80%99oubliez%20pas%20de%20nous%20envoyer%20cet%20email%C2%A0!%20Sinon%2C%20on%20ne%20pourra%20pas%20vous%20contacter%20ni%20vous%20inviter%20sur%20Slack.%0A%0AAmiti%C3%A9%2C%0AL%E2%80%99%C3%A9quipe%20OpenFisca%0A%0A%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%20ENGLISH%20VERSION%20%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%0A%0AHi%2C%20%0A%0AWe're%20glad%20to%20see%20you%20here!%20%F0%9F%98%83%0A%0APlease%20tell%20us%20a%20bit%20about%20you%20and%20why%20you%20want%20to%20join%20the%20OpenFisca%20community%20on%20Slack.%0A%0AAlso%2C%20if%20you%20can%20fill%20out%20this%20short%20survey%2C%20even%20better!%0Ahttps%3A%2F%2Fgoo.gl%2Fforms%2FsOg8K1abhhm441LG2.%0A%0ADon't%20forget%20to%20send%20us%20this%20email!%20Otherwise%20we%20won't%20be%20able%20to%20contact%20you%20back%2C%20nor%20invite%20you%20on%20Slack.%0A%0ACheers%2C%0AThe%20OpenFisca%20Team)
  [![Python](https://img.shields.io/pypi/pyversions/openfisca-france.svg)](https://pypi.python.org/pypi/openfisca-france)
  [![PyPi](https://img.shields.io/pypi/v/openfisca-france.svg?style=flat)](https://pypi.python.org/pypi/openfisca-france)
  [![Gitpod](https://camo.githubusercontent.com/1eb1ddfea6092593649f0117f7262ffa8fbd3017/68747470733a2f2f676974706f642e696f2f627574746f6e2f6f70656e2d696e2d676974706f642e737667)](https://gitpod-referer.now.sh/api/gitpod-referer-redirect)



  OpenFisca is a versatile microsimulation free software. This repository contains the OpenFisca model of the French tax and benefit system. Therefore, the working language here is French. You can however check the [general OpenFisca documentation](https://openfisca.org/doc/) in English!
  > We host a public instance of of the [OpenFisca-France Web API](https://api.fr.openfisca.org/latest/). Learn more about its endpoint in the [Swagger documentation](https://legislation.fr.openfisca.org/swagger).
  > If you need to run large amount of calculations, or add extensions, you should [host your own instance](#servez-openfisca-france-avec-lapi-web-openfisca).



  [OpenFisca](https://www.openfisca.fr/) est un logiciel libre de micro-simulation. Ce dépôt contient la modélisation du système social et fiscal français. Pour plus d'information sur les fonctionnalités et la manière d'utiliser OpenFisca, vous pouvez consulter la [documentation générale](https://openfisca.org/doc/).
  > Nous mettons à disposition une instance publique de [l'API Web OpenFisca-France](https://api.fr.openfisca.org/latest/). Découvrez ses capacité sur sa [documentation Swagger](https://legislation.fr.openfisca.org/swagger).
  > Si vous avez besoin de réaliser un grand nombre de calculs ou d'ajouter des extensions, vous pouvez [servir votre propre instance](#servez-openfisca-france-avec-lapi-web-openfisca).



  OpenFisca met à disposition une [API Web publique](https://openfisca.org/doc/openfisca-web-api/endpoints.html) qui ne demande aucune installation.
  Utilisez l'API publique si vous souhaitez :
  - accéder à un paramètre (Ex : [le montant du Smic horaire brut](https://api.fr.openfisca.org/latest/parameter/marche_travail.salaire_minimum.smic.smic_b_horaire)) ;
  - consulter une formule de calcul (Ex : [le calcul de l'allocation de base des allocations familiales](https://api.fr.openfisca.org/latest/variable/af_base)) ;
  - faire des calculs sur une situation (Ex : le calcul du coût du travail).

  L'ensembles des endpoints sont décrits dans la [documentation Swagger](https://legislation.fr.openfisca.org/swagger).

  [L'explorateur de législation](https://legislation.fr.openfisca.org/swagger) contient la liste des paramètres et variables disponibles.



  Ce paquet requiert [Python 3.9](https://www.python.org/downloads/release/python-390/) et [pip](https://pip.pypa.io/en/stable/installing/) ou [conda](https://www.anaconda.com/products/individual).

  Plateformes supportées :
  - distributions GNU/Linux (en particulier Debian and Ubuntu) ;
  - Mac OS X ;
  - Windows : Nous recommandons d'utiliser [conda](https://www.anaconda.com/products/individual), voir la procédure ci-dessous [Installez un environnement virtuel avec conda](./README.md#installez-un-environnement-virtuel-avec-conda)  ; OpenFisca fonctionne également dans le [sous-système Windows pour Linux (WSL)](https://docs.microsoft.com/fr-fr/windows/wsl/install). Dans ce dernier cas, il suffit de suivre la procédure pour Linux car vous êtes alors dans un environnement Linux.

  Pour les autres OS : si vous pouvez exécuter Python et Numpy, l'installation d'OpenFisca devrait fonctionner.



  Nous recommandons l'utilisation d'un [environnement virtuel](https://virtualenv.pypa.io/en/stable/) (_virtualenv_) avec un gestionnaire de _virtualenv_ tel que [Pew](https://github.com/berdario/pew). Vous pouvez aussi utiliser le gestionnaire d'environnemnt officiel de Python : [venv](https://docs.python.org/3/library/venv.html).

  - Un _[virtualenv](https://virtualenv.pypa.io/en/stable/)_ crée un environnement pour les besoins spécifiques du projet sur lequel vous travaillez.
  - Un gestionnaire de _virtualenv_, tel que [Pew](https://github.com/berdario/pew), vous permet de facilement créer, supprimer et naviguer entre différents projets.

  Pour installer Pew, lancez une fenêtre de terminal et suivez ces instructions :

  ```sh
  python --version # Python 3.9.0 ou plus récent devrait être installé sur votre ordinateur.

  ```

  ```sh
  pip install --upgrade pip
  pip install pew
  ```
  Créez un nouveau _virtualenv_ nommé **openfisca** et configurez-le avec python 3.9 :

  ```sh
  pew new openfisca --python=python3.9

  ```
  Le  _virtualenv_  **openfisca** sera alors activé, c'est-à-dire que les commandes suivantes s'exécuteront directement dans l'environnement virtuel. Vous verrez dans votre terminal :

  ```sh
  Installing setuptools, pip, wheel...done.
  Launching subshell in virtual environment. Type 'exit' or 'Ctrl+D' to return.
  ```

  Informations complémentaires :
  - sortez du _virtualenv_ en tapant `exit` (or Ctrl-D) ;
  - re-rentrez en tapant `pew workon openfisca` dans votre terminal.

  Bravo :tada: Vous êtes prêt·e à installer OpenFisca-France !

  Nous proposons deux procédures d'installation. Choisissez l'installation A ou B ci-dessous en fonction de l'usage que vous souhaitez faire d'OpenFisca-France.



  Suivez cette installation si vous souhaitez :
  - procéder à des calculs sur une large population ;
  - créer des simulations fiscales ;
  - écrire une extension au-dessus de la législation française (exemple : les extensions de [Paris](https://github.com/sgmap/openfisca-paris) et [Rennes](https://github.com/sgmap/openfisca-rennesmetropole) ;
  - servir OpenFisca-France avec l'API Web OpenFisca.

  Pour pouvoir modifier OpenFisca-France, consultez l'[Installation avancée](#b-installation-avancée-git-clone).



  Dans votre _virtualenv_, vérifiez les pré-requis :

  ```sh
  python --version  # Devrait afficher "Python 3.9.xx".

  ```

  ```sh
  pip --version  # Devrait afficher au moins 9.0.x

  ```
  Installez OpenFisca-France :

  ```sh
  pip install openfisca-france && pip install openfisca-core[web-api]
  ```
  > _Note: La deuxième partie de la commande, à partir du `&&`, est optionnelle. Elle vous permet d'installer l'API Web d'OpenFisca._

  Félicitations :tada: OpenFisca-France est prêt à être utilisé !



  - Apprenez à utiliser OpenFisca avec nos [tutoriels](https://openfisca.org/doc/) (en anglais).
  - Hébergez et servez votre instance d'OpenFisca-France avec l'[API Web OpenFisca](#servez-openfisca-france-avec-lapi-web-openfisca).

  En fonction de vos projets, vous pourriez bénéficier de l'installation des paquets suivants dans votre _virtualenv_ :
  - pour installer une extension ou écrire une législation au-dessus d'OpenFisca-France, consultez la [documentation sur les extensions](https://openfisca.org/doc/contribute/extensions.html) (en anglais) ;
  - pour représenter graphiquement vos résultats, essayez la bibliothèque [matplotlib](http://matplotlib.org/) ;
  - pour gérer vos données, découvrez la bibliothèque [pandas](http://pandas.pydata.org/).



  Suivez cette installation si vous souhaitez :
  - enrichir ou modifier la législation d'OpenFisca-France ;
  - contribuer au code source d'OpenFisca-France.



  Premièrement, assurez-vous que [Git](https://www.git-scm.com/) est bien installé sur votre machine.

  Dans votre _virtualenv_, assurez-vous que vous êtes dans le répertoire où vous souhaitez cloner OpenFisca-France.

  Vérifiez les pré-requis :

  ```sh
  python --version  # Devrait afficher "Python 3.9.xx".

  ```

  ```sh
  pip --version  # Devrait afficher au moins 23.0.

  ```

  Clonez OpenFisca-France sur votre machine :

  ```sh
  git clone https://github.com/openfisca/openfisca-france.git
  cd openfisca-france
  pip install --editable .[dev] && pip install openfisca-core[web-api]
  ```

  Vous pouvez vous assurer que votre installation s'est bien passée en exécutant :

  ```sh
  pytest tests/test_basics.py # Ces test peuvent prendre jusqu'à 60 secondes.
  ```
  :tada: OpenFisca-France est prêt à être utilisé !



  Nous conseillons cette procédure pour les personnes utilisant Windows et n'ayant pas d'environnement Python fonctionnel. Elle fonctionne également sous Linux et macOS.

  Ceci vous permet d'obtenir en une seule installation :
  - Python
  - Le gestionnaire de paquets [Anaconda.org](https://docs.anaconda.com/anacondaorg/user-guide/)
  - Le gestionnaire d'environnement Python virtuel : [conda](https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html)

  Voici les étapes à suivre :

  - Installer la version communautaire/gratuite en suivant la procédure décrite sur [le site Anaconda](https://www.anaconda.com/products/individual). A noter que Anaconda occupe beaucoup d'espace disque (>2 Go), vous pouvez installer à la place [Miniconda](https://docs.conda.io/projects/conda/en/latest/user-guide/install/windows.html) qui occupe beaucoup moins d'espace disque. Cependant vous n'aurez pas l'interface graphique [Anaconda Navigator](https://docs.anaconda.com/anaconda/navigator/index.html) qui vous permet de gérer vos environnements. Si vous êtes habituée à gérer les choses en ligne de commande, préfèrez Miniconda.
  - Depuis le menu démarrer, exécuter `Anaconda Powershell Prompt`. Ou utiliser votre shell préféré avec Miniconda, il vous faudra peut-être utiliser la commande `conda init`, mais conda vous le dira.
  - Exécuter les commandes suivantes dans le shell:
    - Ajouter `conda-forge` comme channel par défaut : `conda config --add channels conda-forge && conda config --set channel_priority strict `
    - Créer un environnement virtuel dédié : `conda create --name openfisca python=3.9`
    - Activer l'environnement : `conda activate openfisca`
    - Installer OpenFisca : `conda install openfisca-france`

  :tada: OpenFisca-France est prêt à être utilisé !

  Ensuite, pour quitter l'environnement OpenFisca : `conda deactivate`

  Pour y revenir : `conda activate openfisca`

  A noter que OpenFisca-France est présent sur [conda-forge](https://anaconda.org/conda-forge/openfisca-france) et sur un _channel_ dédié [openfisca](https://anaconda.org/openfisca/openfisca-france). C'est conda-forge qui est mis en avant dans cette documentation, car accessible par défaut dans les installations Anaconda.

  A noter que l'installation d'Openfisca-France peut lever une erreur sur certaines machines Windows à cause de la longueur des chemins de certains fichiers de paramètres et des restrictions de longueur de chemin sous Windows. Une option possible pour résoudre ce problème est de lever cette limite (voir cette documentation pour [Windows >=10](https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation?tabs=registry#enable-long-paths-in-windows-10-version-1607-and-later))



  - Pour enrichir ou faire évoluer la législation d'OpenFisca-France, lisez _[Coding the Legislation](https://openfisca.org/doc/coding-the-legislation/index.html)_ (en anglais).
  - Pour contribuer au code, lisez le _[Contribution Guidebook](https://openfisca.org/doc/contribute/index.html)_ (en anglais).



  Pour faire tourner les tests d'OpenFisca-France, exécutez la commande suivante :

  ```sh
  make test
  ```



  Ce dépôt adhère à un style de code précis, et on vous invite à le suivre pour que vos contributions soient intégrées au plus vite.

  L'analyse de style est déjà exécutée avec `make test`. Pour le faire tourner de façon indépendante :

  ```sh
  make check-style
  ```

  Pour corriger les erreurs de style de façon automatique:

  ```sh
  make format-style
  ```

  Pour corriger les erreurs de style de façon automatique à chaque fois que vous faites un _commit_ :

  ```sh
  touch .git/hooks/pre-commit
  chmod +x .git/hooks/pre-commit

  tee -a .git/hooks/pre-commit << END



  exec make format-style
  END
  ```



  Il est possible de servir l'API Web d'OpenFisca-France sur votre propre serveur :

  ```sh
  openfisca serve
  ```

  Pour en savoir plus sur la commande `openfisca serve` et ses options, consultez la [documentation de référence](https://openfisca.org/doc/openfisca-python-api/openfisca_serve.html).

  Testez votre installation en requêtant la commande suivante :

  ```sh
  curl "http://localhost:5000/parameter/marche_travail.salaire_minimum.smic.smic_b_horaire"
  ```
  Vous devriez avoir le resultat suivant :
  ```JSON
  {
    "description": "Smic horaire brut",
    "id": "marche_travail.salaire_minimum.smic.smic_b_horaire",
    "values": {
      "2001-08-01": 6.67,
      "2002-07-01": 6.83,
      "2003-07-01": 7.19,
      "2004-07-01": 7.61,
      "2005-07-01": 8.03,
      "2006-07-01": 8.27,
      "2007-07-01": 8.44,
      "2008-05-01": 8.63,
      "2008-07-01": 8.71,
      "2009-07-01": 8.82,
      "2010-01-01": 8.86,
      "2011-01-01": 9.0,
      "2011-12-01": 9.19,
      "2012-01-01": 9.22,
      "2012-07-01": 9.4,
      "2013-01-01": 9.43,
      "2014-01-01": 9.53,
      "2015-01-01": 9.61,
      "2016-01-01": 9.67,
      "2017-01-01": 9.76
    }
  }
  ```

  :tada: Vous servez OpenFisca-France via l'API Web OpenFisca !

  Pour en savoir plus, explorez [la documentation de l'API Web](https://legislation.fr.openfisca.org/swagger).

  Vous pouvez activer le suivi des visites sur votre instance via Piwik avec _[le Tracker API OpenFisca](https://github.com/openfisca/tracker)_ (en anglais).



  Le code d'OpenFisca-France est déployé de manière continue et automatique. Ainsi, à chaque fois que le code de la législation évolue sur la branche principale `master`, une nouvelle version est publiée.

  De nouvelles versions sont donc publiées très régulièrement. Cependant, la différence entre deux versions consécutives étant réduite, les efforts d'adaptation pour passer de l'une à l'autre sont en général très limités.

  Par ailleurs, OpenFisca-France respecte les règles du [versionnement sémantique](http://semver.org/). Tous les changements qui ne font pas l'objet d'une augmentation du numéro majeur de version sont donc garantis rétro-compatibles.

  > Par exemple, si mon application utilise la version `13.1.1`, je sais qu'elle fonctionnera également avec la version `13.2.0`. En revanche, il est possible qu'une adaptation soit nécessaire sur mon client pour pouvoir utiliser la version `14.0.0`.

  Enfin, les impacts et périmètres des évolutions sont tous documentés sur le [CHANGELOG](CHANGELOG.md) du package. Ce document permet aux contributeurs de suivre les évolutions et d'établir leur propre stratégie de mise à jour.



  Voir la [liste des contributeurs](https://github.com/openfisca/openfisca-france/graphs/contributors).


pkgId: 16e5ba7f87d1e481cb643daaa581f534b7273af8b8b11eb87480418773222e69
name: python-OpenFisca-Tunisia-help
arch: noarch
version: 0.41.3
epoch: 0
release: 1
summary: Development documents and examples for OpenFisca-Tunisia
url: https://github.com/openfisca/openfisca-tunisia
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-OpenFisca-Tunisia-0.41.3-1.src.rpm
location_href: Packages/python-OpenFisca-Tunisia-help-0.41.3-1.noarch.rpm
checksum_type: sha256
description:
  [![Newsletter](https://img.shields.io/badge/newsletter-subscribe!-informational.svg?style=flat)](mailto:contact%40openfisca.org?subject=Subscribe%20to%20your%20newsletter%20%7C%20S'inscrire%20%C3%A0%20votre%20newsletter&body=%5BEnglish%20version%20below%5D%0A%0ABonjour%2C%0A%0AVotre%C2%A0pr%C3%A9sence%C2%A0ici%C2%A0nous%C2%A0ravit%C2%A0!%20%F0%9F%98%83%0A%0AEnvoyez-nous%20cet%20email%20pour%20que%20l'on%20puisse%20vous%20inscrire%20%C3%A0%20la%20newsletter.%20%0A%0AAh%C2%A0!%20Et%20si%20vous%20pouviez%20remplir%20ce%20petit%20questionnaire%2C%20%C3%A7a%20serait%20encore%20mieux%C2%A0!%0Ahttps%3A%2F%2Fgoo.gl%2Fforms%2F45M0VR1TYKD1RGzX2%0A%0AAmiti%C3%A9%2C%0AL%E2%80%99%C3%A9quipe%20OpenFisca%0A%0A%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%20ENGLISH%20VERSION%20%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%0A%0AHi%2C%20%0A%0AWe're%20glad%20to%20see%20you%20here!%20%F0%9F%98%83%0A%0APlease%20send%20us%20this%20email%2C%20so%20we%20can%20subscribe%20you%20to%20the%20newsletter.%0A%0AAlso%2C%20if%20you%20can%20fill%20out%20this%20short%20survey%2C%20even%20better!%0Ahttps%3A%2F%2Fgoo.gl%2Fforms%2FsOg8K1abhhm441LG2%0A%0ACheers%2C%0AThe%20OpenFisca%20Team)
  [![Twitter](https://img.shields.io/badge/twitter-follow%20us!-9cf.svg?style=flat)](https://twitter.com/intent/follow?screen_name=openfisca)
  [![Slack](https://img.shields.io/badge/slack-join%20us!-blueviolet.svg?style=flat)](mailto:contact%40openfisca.org?subject=Join%20you%20on%20Slack%20%7C%20Nous%20rejoindre%20sur%20Slack&body=%5BEnglish%20version%20below%5D%0A%0ABonjour%2C%0A%0AVotre%C2%A0pr%C3%A9sence%C2%A0ici%C2%A0nous%C2%A0ravit%C2%A0!%20%F0%9F%98%83%0A%0ARacontez-nous%20un%20peu%20de%20vous%2C%20et%20du%20pourquoi%20de%20votre%20int%C3%A9r%C3%AAt%20de%20rejoindre%20la%20communaut%C3%A9%20OpenFisca%20sur%20Slack.%0A%0AAh%C2%A0!%20Et%20si%20vous%20pouviez%20remplir%20ce%20petit%20questionnaire%2C%20%C3%A7a%20serait%20encore%20mieux%C2%A0!%0Ahttps%3A%2F%2Fgoo.gl%2Fforms%2F45M0VR1TYKD1RGzX2%0A%0AN%E2%80%99oubliez%20pas%20de%20nous%20envoyer%20cet%20email%C2%A0!%20Sinon%2C%20on%20ne%20pourra%20pas%20vous%20contacter%20ni%20vous%20inviter%20sur%20Slack.%0A%0AAmiti%C3%A9%2C%0AL%E2%80%99%C3%A9quipe%20OpenFisca%0A%0A%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%20ENGLISH%20VERSION%20%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%3D%0A%0AHi%2C%20%0A%0AWe're%20glad%20to%20see%20you%20here!%20%F0%9F%98%83%0A%0APlease%20tell%20us%20a%20bit%20about%20you%20and%20why%20you%20want%20to%20join%20the%20OpenFisca%20community%20on%20Slack.%0A%0AAlso%2C%20if%20you%20can%20fill%20out%20this%20short%20survey%2C%20even%20better!%0Ahttps%3A%2F%2Fgoo.gl%2Fforms%2FsOg8K1abhhm441LG2.%0A%0ADon't%20forget%20to%20send%20us%20this%20email!%20Otherwise%20we%20won't%20be%20able%20to%20contact%20you%20back%2C%20nor%20invite%20you%20on%20Slack.%0A%0ACheers%2C%0AThe%20OpenFisca%20Team)
  [![Python](https://img.shields.io/pypi/pyversions/openfisca-tunisia.svg)](https://pypi.python.org/pypi/openfisca-tunisia)
  [![PyPi](https://img.shields.io/pypi/v/openfisca-tunisia.svg?style=flat)](https://pypi.python.org/pypi/openfisca-Tunisia)
  [![Gitpod](https://camo.githubusercontent.com/1eb1ddfea6092593649f0117f7262ffa8fbd3017/68747470733a2f2f676974706f642e696f2f627574746f6e2f6f70656e2d696e2d676974706f642e737667)](https://gitpod-referer.now.sh/api/gitpod-referer-redirect)



  [OpenFisca](http://openfisca.org) est un logiciel libre de micro-simulation.
  Ceci est le code source du module dédié à la Tunisie.

  <p align='right'>الجباية المفتوحة برنامج حر لمحاكاة النظام الجبائي.
   هذا مصدر البرنامج للوحدة الخاصة بتونس</p>

  [OpenFisca](http://openfisca.org) is a versatile microsimulation free software.
  This is the source code of the Tunisia module.



  Un démonstrateur vous est proposé sous la forme d'un Notebook Jupyter.
  Vous serez redirigé vers celui-ci en cliquant sur le lien suivant (le chargement prendra quelques secondes) :
  <code><p align='center'>[![Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/openfisca/openfisca-tunisia/master?filepath=notebooks%2Fdemo.ipynb)</p></code>
  Vous accédez ainsi à un démonstrateur modifiable où il vous est possible de tester openfisca-tunisia.

  <p align='right'>ستجدون لعبة تجريبية في شكل دفتر جوبيتر على الرابط التالي</p>

  <code><p align='center'>[![Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/openfisca/openfisca-tunisia/master?filepath=notebooks%2Fdemo.ipynb)</p></code>
  <p align='right'>يسمح هذا الدفتر بتجريب الجباية المفتوحة لتونس</p>

  A demo is available in a Jupyter Notebook.
  You will be redirected to it by clicking on the following link (wait a few seconds to load it):
  <code><p align='center'>[![Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/openfisca/openfisca-tunisia/binder?filepath=notebooks%2Fdemo.ipynb)</p></code>
  Then you will be in an interactive demo where you will be able to play with openfisca-tunisia.

  > This demo is available thanks to [Binder](https://mybinder.org/) and [Jupyter](http://jupyter.org) projects.



  Les paramêtres de la législation peuvent être consultés avec [une interface dédiée](https://parameters.tn.tax-benefit.org/parameters/).

  يمكن الاطلاع على معايير التشريع من خلال واجهة مخصصة لذلك

  Legislation parameters can be consulted via [a dedicated interface](https://parameters.tn.tax-benefit.org/parameters/).



  OpenFisca est un projet de logiciel libre.

  Son code source est distribué sous la licence [GNU Affero General Public Licence](http://www.gnu.org/licenses/agpl.html)
  version 3 ou ultérieure (cf. [LICENSE](https://github.com/openfisca/openfisca-tunisia/blob/master/LICENSE)).

  N'hésitez pas à rejoindre l'équipe de développement OpenFisca !
  Pour en savoir plus, une [documentation](http://openfisca.org/doc/contribute/index.html) est à votre disposition.


  <p align='right'> الجباية المفتوحة برنامج حر</p>

  <p align='right'> تم توزيع مصدر هذا البرنامج تحت رخصة أفيرو العامة الثالثة أو ما أعلى</p>

  <p align='right'>تعالوا انضموا إلى فريق الجباية المفتوحة و ساهموا في تطوير البرنامج! للمزيد من المعلومات، يرجى زيارة الموقع الإلكتروني الرسمي</p>


  OpenFisca is a free software project.

  Its source code is distributed under the [GNU Affero General Public Licence](http://www.gnu.org/licenses/agpl.html)
  version 3 or later (see [LICENSE](https://github.com/openfisca/openfisca-tunisia/blob/master/LICENSE) file).

  Feel free to join the OpenFisca development team!
  See the [documentation](http://openfisca.org/doc/contribute/index.html) for more information.



  * [Documentation générale](http://openfisca.org/doc/) du projet OpenFisca (tous pays confondus)
    - Et son [architectture](https://openfisca.org/doc/architecture.html) d'un projet OpenFisca
  <!-- * [Explorateur de la législation](https://legislation.openfisca.tn) couverte par OpenFisca-Tunisia -->
  * [Wiki](https://github.com/openfisca/openfisca-tunisia/wiki) OpenFisca-Tunisia
  * [Google Drive public](https://drive.google.com/drive/folders/1xzrwEgZF2pEMUIHMQMWtlg7ubIFdy58N?usp=sharing) de références législatives

  Par ailleurs, chaque module de la [famille OpenFisca sur GitHub](https://github.com/openfisca) dispose d'une documentation propre (voir `README.md` respectifs).



  Sous Unix/macOS/Linux, appliquez les étapes qui suivent dans votre Terminal.

  Sous Windows, installez un émulateur de terminal avant de poursuivre.
  Nous vous conseillons en particulier l'émulateur BASH fourni avec le [gestionnaire de version GIT](https://git-for-windows.github.io).
  En l'intégrant à un outil tel que [Visual Studio Code](https://code.visualstudio.com), vous aurez un environnement fonctionnel pour travailler sur le code source.
  Néanmoins, vous aurez à effectuer des vérifications complémentaires à ce qui est décrit ci-dessous (telles que vérifier la configuration de votre variable d'environnement `%PATH%`).



  Ce projet nécessite l'installation préalable des éléments suivants :
  * Le langage [Python 3.9](https://www.python.org/downloads/)
  * Le gestionnaire de paquets [pip](https://pip.pypa.io/en/stable/installing/).

  Vérifiez alors que la version de python appelée par défaut débute bien par `3.9` :

  ```
  python --version
  ```

  Et installez les éventuelles mises à jour pour la gestion de paquets python avec :

  ```
  sudo pip install --upgrade pip wheel
  ```

  Ensuite, afin de créer un environnement de travail propre et pour vous permettre de faire cohabiter plusieurs contextes de travail en python,
  nous vous conseillons l'utilisation d'environnements virtuels, dits virtualenv.
  Il vous faut alors installer un gestionnaire de virtualenv python (tel que [pew](https://github.com/berdario/pew)).

  ```
  sudo pip install pew
  ```

  Il vous est désormais possible de créer votre premier environnement dédié à OpenFisca-Tunisia. Nommons-le `openfisca` :

  ```
  pew new openfisca --python=python3.9

  ```

  Usage :
  * Vous pouvez sortir du virtualenv en tapant `exit` (ou Ctrl-D)
  * Vous pouvez le réactiver grâce à `pew workon openfisca`



  Deux options s'offrent à vous :
  * Installer le module python pré-compilé dit [wheel python](https://pypi.org/project/OpenFisca-Tunisia/)
  * Ou, installer le code source



  Installer le module pré-compilé d'`OpenFisca-Tunisia` vous permet d'interroger le modèle socio-fiscal tunisien.

  Nous supposons que vous avez activé votre environnement virtuel.
  Appliquez alors la commande suivante pour récupérer la wheel `OpenFisca-Tunisia` depuis la librairie de paquets Python [pypi](https://pypi.org) :

  ```sh
  pip install openfisca-tunisia
  ```

  :tada: Félicitations, vous avez désormais terminé l'installation d'OpenFisca Tunisia !

  Vous pouvez vérifier sa présence dans votre environnement courant avec :
  ```sh
  pip list

  ```



  Installer le code source d'`OpenFisca-Tunisia` sur votre ordinateur vous permet d'interroger ou de modifier le modèle socio-fiscal tunisien.

  Nous supposons que vous avez activé votre environnement virtuel et que vous vous situez dans le répertoire où vous souhaitez placer le projet.
  Appliquez alors les commandes suivantes pour récupérer les sources d'OpenFisca-Tunisia et configurer le projet (sans omettre le point en fin de ligne :slightly_smiling_face:) :

  ```
  git clone https://github.com/openfisca/openfisca-tunisia.git
  cd openfisca-tunisia
  pip install -e .
  ```

  :tada: Félicitations, vous avez désormais terminé l'installation d'OpenFisca Tunisia !

  Vous pouvez vérifier que votre environnement fonctionne bien en démarrant les tests tel que décrit dans le paragraphe suivant.



  Nous supposons que vous êtes dans le répertoire `openfisca-tunisia` et que votre environnement virtuel est activé.
  Commencez par installer les outils de test avec :

  ```
  pip install -e .[dev]
  ```

  Différents formats de tests sont alors à votre disposition : la rédaction de tests est possible en python ou en yaml.



  Un test rédigé en python peut être exécuté avec l'outil [pytest](https://docs.pytest.org).
  Celui-ci déroulera les fonctions python dont le nom commence par le mot `test`.

  Ainsi, pour exécuter le test python `tests/test_simple.py`, utilisez la commande suivante :

  ```
  pytest tests/test_simple.py
  ```

  Il vous est également possible de n'exécuter qu'un seul test d'un fichier. Dans l'exemple suivant, `test_1_parent` sera l'unique test déroulé du fichier `tests/core_tests.py` :

  ```
  pytest tests/core_tests.py::test_1_parent
  ```



  Le format d'un test yaml est décrit dans la [section YAML tests](http://openfisca.org/doc/coding-the-legislation/writing_yaml_tests.html) de la documentation officielle.
  Ainsi, si vous souhaitez exécuter le test yaml `tests/formulas/irpp.yaml`, utilisez la commande :

  ```sh
  openfisca test -c openfisca_tunisia tests/formulas/irpp.yaml
  ```



  Afin de tester avec un debugger, ajoutez un point d'arrêt dans le code python appelé par le test avec :
  ```py
  import ipdb; ipdb.set_trace()
  ```

  Installez la librairie `ipdb` avec :
  ```sh
  pip install ipdb
  ```

  Et exécutez à nouveau le test (avec l'option `-s` pour la commande `pytest`).




  L'ensemble des tests et exemples définis dans OpenFisca-Tunisia peut être exécuté avec une commande. Néanmoins, cela nécessite l'installation de librairies complémentaires pour les exemples rédigés sous forme de [notebooks Jupyter](http://jupyter.org) :

  ```
  pip install -e .[notebook]
  ```

  Le tout peut ensuite être démarré grâce à la commande suivante :

  ```
  make test
  ```

  Pour en savoir plus, voir [la section Tests](http://openfisca.org/doc/contribute/tests.html) de la documentation officielle.



  L'API est issue du dépôt [GitHub du module central OpenFisca-Core](https://github.com/openfisca/openfisca-core).

  Pour consulter sa version `v0.13.0`, il suffit d'interroger l'un de ses points d'entrée.
  La liste des paramètres est par exemple consultable à l'adresse suivante :
  ```
  www.openfisca.tn/api/v0.13.0/parameters
  ```
  Pour en savoir plus, nous vous conseillons la lecture de sa [documentation officielle](http://openfisca.org/doc/openfisca-web-api/preview-api.html).


pkgId: 865b8df68c00e8f533620b8acbd4ddeda2336475d09e2e365dda55586015cdbc
name: python-OpenweatherApp-help
arch: noarch
version: 0.1
epoch: 0
release: 1
summary: Development documents and examples for OpenweatherApp
url: https://github.com/Maria-Kochetkova/LR_Prog_5_sem/tree/main/lr3
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-OpenweatherApp-0.1-1.src.rpm
location_href: Packages/python-OpenweatherApp-help-0.1-1.noarch.rpm
checksum_type: sha256
description:
  Приложение для получения данных с openweather посредством API

  Ссылка на github:

  https://github.com/Maria-Kochetkova/LR_Prog_5_sem/tree/main/lr3



  ```
  pip install OpenweatherApp
  ```


pkgId: 94c13596c74d57a876f8a89a2305c49b98bfd5138d15f0f3b108b7c7075e37d5
name: python-Orbital-Visualizator-help
arch: noarch
version: 0.1
epoch: 0
release: 1
summary: Development documents and examples for Orbital-Visualizator
url: https://github.com/ArpaxSpaceSystems/Orbital_Visualizator.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Orbital-Visualizator-0.1-1.src.rpm
location_href: Packages/python-Orbital-Visualizator-help-0.1-1.noarch.rpm
checksum_type: sha256
description:
  Gives a 3D representation of a given orbit from TLE (Two Lines Elements) or directly from Keplerian paramaters.


  Documentation of methods and functions can be found in ``> docs/source > index.rst``


pkgId: 9ef5ab0a22c7945346ddeb7b542182593ca5ae7b3021a30e1e48539967fbbf49
name: python-OrcFxAPI
arch: noarch
version: 11.5.1
epoch: 0
release: 1
summary: Python interface to the OrcaFlex API
url: https://www.orcina.com/
rpm_license: Commercial
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-OrcFxAPI-11.5.1-1.src.rpm
location_href: Packages/python-OrcFxAPI-11.5.1-1.noarch.rpm
checksum_type: sha256
description:
  OrcaFlex (https://www.orcina.com/orcaflex/), developed by Orcina Ltd.
  (https://www.orcina.com/), is a finite element analysis tool used primarily for offshore engineering.
  OrcaFlex has a powerful graphical user interface (GUI) that makes tasks such as model development
  very efficient.
  The program also offers a number of methods to automate its use. These range from
  Excel based automation facilities to the low-level programming interface, known as OrcFxAPI.
  Interfaces with a number of different programming languages are available. At the time of writing
  these languages are: C, C++, C#, Delphi, Matlab and Python.
  This package implements the Python interface to the OrcaFlex API. Documentation can be found
  at https://www.orcina.com/webhelp/OrcFxAPI/


pkgId: abf7131dfcdd39f0f266d67867b3cf6738a9b8a2286fbb654cd8e7f3dadfc7f8
name: python-Organizze-Wrapper-help
arch: noarch
version: 1.3.2
epoch: 0
release: 1
summary: Development documents and examples for Organizze-Wrapper
url: https://github.com/anderbytes/Organizze-Wrapper
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Organizze-Wrapper-1.3.2-1.src.rpm
location_href: Packages/python-Organizze-Wrapper-help-1.3.2-1.noarch.rpm
checksum_type: sha256
description:
  Esta biblioteca servirá de apoio para utilização da API do Organizze (www.organizze.com.br).



  Use o gerenciador 'pip' para instalação do pacote.

  ```bash
  pip install organizze-wrapper
  ```



  Para utilização da API, primeiramente você deve gerar uma chave de API em sua conta no Organizze, neste [link](https://app.organizze.com.br/configuracoes/api-keys).

  Para seu código, seguem alguns exemplos de comandos:

  ```python
  from Organizze_Wrapper.API import API


  conn = API(email="seu_email_do_Organizze", token="token gerado no Organizze", autor="Seu_primeiro_nome")


  from Organizze_Wrapper.Categorias import getCategorias

  for cat in getCategorias(conn):
      print(cat)


  from Organizze_Wrapper.Lancamentos import getLancamentos

  for lanc in getLancamentos(conn, dataInicio="2024-06-01", dataFim="2024-06-30"):
      print(lanc)


  from Organizze_Wrapper.Lancamentos import updLancamento

  updLancamento(conn, idLancamento=7353025510, JSON_params={'amount_cents': -44599})


  ```

  A documentação de referência da API oficial da Organizze se encontra em:
  https://github.com/organizze/api-doc



  Pull requests são bem-vindos, principalmente para correção de bugs ou sugestão de melhoria na documentação.

  Para grandes mudanças, sugiro abrir um 'issue' previamente para discussão.

  Quer ajudar?
  - Precisamos melhorar a documentação (mais detalhamentos e exemplos)
  - Precisamos de métodos mais granulares para atualizar campos específicos (e não depender apenas de JSON_Params)

  Sou um desenvolvedor 'solo' nas horas vagas, então sejam pacientes 😉



  Este projeto está publicado em:
  - GitHub: https://github.com/anderbytes/OrganizzeWrapper
  - PyPi: https://pypi.org/project/OrganizzeWrapper/



  [GPLv3](https://gplv3.fsf.org/)


pkgId: 209c53a7d5419d5e69ac4379fb1cdcfac3bea7ab1d9a455c8a1689d95cc897b1
name: python-PAModelpy-help
arch: noarch
version: 0.0.4.2
epoch: 0
release: 1
summary: Development documents and examples for PAModelpy
url: https://pypi.org/project/PAModelpy/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PAModelpy-0.0.4.2-1.src.rpm
location_href: Packages/python-PAModelpy-help-0.0.4.2-1.noarch.rpm
checksum_type: sha256
description:
  Models of metabolism are powerful tools to explore the metabolic potential of microorganism.
  Powerful tools have been created to support Python-based analysis of genome-scale models.
  These models, however, cannot capture all metabolic phenotypes and the simulation results have high flux variability.
  Adding protein to each reaction increases the simulation fidelity.
  The PAModelpy package is designed to integrate protein constraints and protein sectors as described by
  [Alter et al. (2021)](https://journals.asm.org/doi/10.1128/mSystems.00625-20) to metabolic models.
  It is the Python implementation of the [PAM MATLAB framework](https://github.com/Spherotob/PAM_public) to create GECKO like ME models.

  The PAModelpy package builds upon the community-wide used [COBRApy](https://github.com/opencobra/cobrapy/tree/devel).
  We have extended this package with the following features:
  - protein-reaction associations
  - infrastructure to include isozymes and promiscuous enzymes
  - protein sectors
  - specialized objects to build protein allocation models
  - the possibility to perform a computational efficient sensitivity analysis


  [PAModelpy is a PiPy package](https://pypi.org/project/PAModelpy/) which allows for easy installation with pip:

  `pip install PAModelpy`

  Note that the package has been tested with the [Gurobi](https://www.mathworks.com/products/connections/product_detail/gurobi-optimizer.html) solver.


  - **EnzymeSectors**: The objects which are used to store the data of the different enzyme sectors which are added to the genome-scale model
  - **PAModel**: Proteome Allocation (PA) model class. This class builds on to the `cobra.core.Model` class from the COBRApy toolbox with functions to build enzyme sectors, to add enzyme kinetics parameters and in the future to perform a sensitivity analysis on the enzyme variables.
  - **Enzyme**: Different classes which relate enzymes to the model with enzyme constraints and variables.
  - **CatalyticEvent**: A class which serves as an interface between reactions and enzyme. This allows for easy lookup of Protein-Reaction assocations.
  - **PAMValidator**: Functions to validate the model predictions with physiology data and giving a graphical overview. The script uses data for E.coli (found in `./Data/Ecoli_physiology`) by default.


  The dependencies of the PAModelpy package can be found in `src/pyproject.toml`


  Copyright institute of Applied Microbiology, RWTH Aachen University, Aachen, Germany (2023)

  PAModelpy is free of charge open source software, which can be used and modified for your particular purpose under the [MIT](https://opensource.org/license/mit/)
  or [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0) of the users choice.

  Please note that according to these licenses, the software is provided 'as is', WITHOUT WARRANTY OF ANY KIND, without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.


pkgId: 7073efa139864ee00950996969766ffad63d864090c50c02e3c0ad8bc474ef7e
name: python-PEM4Fe-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for PEM4Fe
url: https://github.com/HUSKYzjh/PEM4Fe
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PEM4Fe-1.0.0-1.src.rpm
location_href: Packages/python-PEM4Fe-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  ```
  PEM4Fe/
  ├── src/                  # 核心代码
  │   ├── config.py
  │   ├── fitting.py
  │   ├── peak_detection.py
  │   └── output.py
  ├── tests/                # 测试文件
  │   ├── test_config.py
  │   ├── test_fitting.py
  │   ├── test_peak_detection.py
  │   └── test_output.py
  ├── data/                 # 数据目录（原始数据）
  ├── logs/                 # 日志文件目录
  ├── output/               # 程序输出目录
  ├── requirements.txt      # 依赖库文件
  ├── README.md             # 项目说明文件
  └── PEM4Fe.py               # 主程序入口

  ```


pkgId: 3a53698f0c5fe660e71b9e8f6ffaf1de28b163e0c64bb6f3aed71ccaaac8603c
name: python-PSNAWP-HA-help
arch: noarch
version: 2.2.9
epoch: 0
release: 1
summary: Development documents and examples for PSNAWP-HA
url: https://github.com/isFakeAccount/psnawp
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PSNAWP-HA-2.2.9-1.src.rpm
location_href: Packages/python-PSNAWP-HA-help-2.2.9-1.noarch.rpm
checksum_type: sha256
description:
  Retrieve User Information, Trophies, Game and Store data from the PlayStation Network

  [![PyPI version](https://badge.fury.io/py/PSNAWP.svg)](https://badge.fury.io/py/PSNAWP)
  [![Downloads](https://static.pepy.tech/badge/psnawp)](https://www.pepy.tech/projects/psnawp)
  [![python-logo](https://img.shields.io/badge/python-3.9_|_3.10_|_3.11_|_3.12-blue.svg)](https://www.python.org/)
  [![Checked with pyright](https://microsoft.github.io/pyright/img/pyright_badge.svg)](https://microsoft.github.io/pyright/)
  [![Documentation Status](https://readthedocs.org/projects/psnawp/badge/?version=latest)](https://psnawp.readthedocs.io/en/latest/?badge=latest)
  [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://python-poetry.org/)
  [![pre-commit](https://github.com/isFakeAccount/psnawp/actions/workflows/pre-commit.yaml/badge.svg)](https://github.com/isFakeAccount/psnawp/actions/workflows/pre-commit.yaml)
  [![pytest](https://github.com/isFakeAccount/psnawp/actions/workflows/pytest.yaml/badge.svg)](https://github.com/isFakeAccount/psnawp/actions/workflows/pytest.yaml)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/license/MIT)

  <!-- Pytest Coverage Comment:Begin -->
  \n<!-- Pytest Coverage Comment:End -->





  ```
  pip install PSNAWP
  ```


  > PyPI: https://pypi.org/project/PSNAWP/
  >
  > Read the Docs: https://psnawp.readthedocs.io/en/latest/



  > [!CAUTION]
  > This library is an unofficial and reverse-engineered API wrapper for the PlayStation Network (PSN). It has been developed based on the reverse engineering of the PSN Android app. The API wrapper (>= v2.1.0) will self rate limit at 300 requests per 15 minutes. However, it is still important that you don't send bulk requests using this API. Excessive use of API may lead to your PSN account being temporarily or permanently banned.
  >
  > You can also create a dedicated account to use this library so that in the worst-case scenario you do not lose access to your primary account, along with your video games and progress.

  To get started you need to obtain npsso <64 character code>. You need to follow the following steps

  1. Login into your [My PlayStation](https://my.playstation.com/) account.
  2. In another tab, go to `https://ca.account.sony.com/api/v1/ssocookie`
  3. If you are logged in you should see a text similar to this

  ```json
  {"npsso":"<64 character npsso code>"}
  ```
  This npsso code will be used in the api for authentication purposes. The refresh token that is generated from npsso lasts about 2 months. After that you have to get a new npsso token. The bot will print a warning if there are less than 3 days left in refresh token expiration.

  Following is the quick example on how to use this library

  ```py
  from psnawp_api import PSNAWP
  from psnawp_api.models import SearchDomain
  from psnawp_api.models.trophies import PlatformType

  psnawp = PSNAWP("<64 character npsso code>")


  client = psnawp.me()
  print(f"Online ID: {client.online_id}")
  print(f"Account ID: {client.account_id}")
  print(f"Profile: {client.get_profile_legacy()} \n")


  devices = client.get_account_devices()
  for device in devices:
      print(f"Device: {device} \n")


  friends_list = client.friends_list()
  for friend in friends_list:
      print(f"Friend: {friend} \n")


  blocked_list = client.blocked_list()
  for blocked_user in blocked_list:
      print(f"Blocked User: {blocked_user} \n")


  available_to_play = client.available_to_play()
  for user in available_to_play:
      print(f"Available to Play: {user} \n")


  for trophy in client.trophies("NPWR22810_00", PlatformType.PS4):
      print(trophy)


  groups = client.get_groups()
  first_group_id = None  # This will be used later to test group methods
  for id, group in enumerate(groups):
      if id == 0:  # Get the first group ID
          first_group_id = group.group_id

      group_info = group.get_group_information()
      print(f"Group {id}: {group_info} \n")


  titles_with_stats = client.title_stats()
  for title in titles_with_stats:
      print(
          f" \
          Game: {title.name} - \
          Play Count: {title.play_count} - \
          Play Duration: {title.play_duration} \n"
      )



  example_user_1 = psnawp.user(online_id="VaultTec-Co")  # Get a PSN player by their Online ID
  print(f"User 1 Online ID: {example_user_1.online_id}")
  print(f"User 1 Account ID: {example_user_1.account_id}")

  print(example_user_1.profile())
  print(example_user_1.prev_online_id)
  print(example_user_1.get_presence())
  print(example_user_1.friendship())
  print(example_user_1.is_blocked())


  user_account_id = psnawp.user(account_id="9122947611907501295")
  print(f"User Account ID: {user_account_id.online_id}")



  group = psnawp.group(group_id=first_group_id)  # This is the first group ID we got earlier - i.e. the first group in your groups list
  print(group.get_group_information())
  print(group.get_conversation(10))  # Get the last 10 messages in the group
  print(group.send_message("Hello World"))
  print(group.change_name("API Testing 3"))



  example_user_2 = psnawp.user(online_id="test")
  new_group = psnawp.group(users_list=[example_user_1, example_user_2])
  print(new_group.get_group_information())



  search = psnawp.search(search_query="GTA 5", search_domain=SearchDomain.FULL_GAMES)
  for search_result in search:
      print(search_result["result"]["invariantName"])

   ```

  **Note: If you want to create multiple instances of psnawp you need to get npsso code from separate PSN accounts. If you generate a new npsso with same account your previous npsso will expire immediately.**



  All bug reposts and features requests are welcomed, although I am new at making python libraries, so it may take me a while to implement some features. Suggestions are welcomes if I am doing something that is an unconventional way of doing it.



  This project was not intended to be used for spam, abuse, or anything of the sort. Any use of this project for those purposes is not endorsed. Please keep this in mind when creating applications using this API wrapper.



  This project contains code from PlayStationNetwork::API and PSN-PHP Wrapper that was translated to Python. Also, special thanks @andshrew for documenting the PlayStation Trophy endpoints. All licenses are included in this repository.


pkgId: ba1ca05e7b15182eec20f2fdf70547b8bbac17fca3ce9536c6042a4800996799
name: python-PT3S-help
arch: noarch
version: 90.14.42.0.dev1
epoch: 0
release: 1
summary: Development documents and examples for PT3S
url: https://github.com/aw3s/PT3S
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PT3S-90.14.42.0.dev1-1.src.rpm
location_href: Packages/python-PT3S-help-90.14.42.0.dev1-1.noarch.rpm
checksum_type: sha256
description:
  .

  Use SIR 3S Modeldata and SIR 3S Results in pure Python.

  With pandas, geopandas, matplotlib and others.

  For documentation, test, verification, analysis, reporting, prototyping, play.


pkgId: d79935e9cecaad37650a98fc375cd60348e129f0e77489f7d7e6c689e8816343
name: python-PdfOCRer-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for PdfOCRer
url: https://github.com/msmarkgu/PdfOCRer
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PdfOCRer-1.1.0-1.src.rpm
location_href: Packages/python-PdfOCRer-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  PdfOCRer is a python script that runs OCR on an input PDF (possibly unsearchable) to produce a searchable PDF.

  It uses [Paddle OCR](https://paddlepaddle.github.io/PaddleOCR/latest/index.html) as the OCR engine. Compared to the famous OCR engine [Tesseract](https://github.com/tesseract-ocr/tesseract), Paddle OCR shows better results for Chinese language in my experiments. However, it cannot seem to generate searchable PDF from its OCR result, whereas Tesseract can. If that's what you need, PdfOCRer can help.

  PdfOCRer processes a PDF in four steps:

  - Step 1: convert each pdf page into an image (default format PNG).
  - Step 2: run OCR on each image to recognize text and bounding boxes.
  - Step 3: add text/bbox on image as hidden layer to make 1-page PDF.
  - Step 4: merge all 1-page pdfs to output the result searchable pdf.



  The script is tested in Python 3.10. It should work as long as the dependencies work.

  - Paddle OCR: follow its instruction [here](https://paddlepaddle.github.io/PaddleOCR/latest/ppocr/quick_start.html).

  - PyPDF2, Pillow, ReportLab: ``` pip install pillow PyPDF2 reportlab ```

  - Ghostscript: used to convert pdf to images, called from the script as subprocess.

      -- on Linux/Ubuntu: ``` apt-get install ghostscript ```,

      -- on MacOS machine: ``` brew install ghostscript ```.



  Open a terminal, run the script like following:

  ```
  python pdf_ocrer.py -i <input_pdf> -o <output_pdf> -l <language> -t <temp_dir> [--debug]
  ```

  Example:

  ```
  python pdf_ocrer.py -i ../example/scanned_page.pdf -o ../example/scanned_page.ocr.pdf -t ../temp -l ch --debug
  ```



  Thanks to the authors of all the depencenies libraries, the Python and Open Source Community.


pkgId: b19a872cd25e438da116d2589a7824efdfaf4d63f009082043a99ea9e9c3611f
name: python-PetThermoTools-help
arch: noarch
version: 0.2.27
epoch: 0
release: 1
summary: Development documents and examples for PetThermoTools
url: https://github.com/gleesonm1/PetThermoTools
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PetThermoTools-0.2.27-1.src.rpm
location_href: Packages/python-PetThermoTools-help-0.2.27-1.noarch.rpm
checksum_type: sha256
description:
  For instructions on the installation and use of PetThermoTools please visit our readthedocs page.

  https://PetThermoTools.readthedocs.io/en/latest/


pkgId: 3963886b40d3d4269440bc398a1c48157b5334768b694a4702e80d54a10954b0
name: python-PiQR-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for PiQR
url: https://github.com/PimpDiCaprio/PiQR
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PiQR-0.1.3-1.src.rpm
location_href: Packages/python-PiQR-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  QR generator tool that returns either a PNG, postscript file, or a postscript object of an input string



  I created this QR generator tool with the express purpose of generating custom QR codes for PDFs without the need for an adobe subscription. The returned postscript data can be used to place into a prewritten postscript file and then converted into a PDF using ghostscript.





  * In order to generate a QR image you will require both cv2 and numpy
    ```sh
    pip install opencv-contrib-python
    pip install numpy
    ```



  * Clone the repo
    ```sh
    git clone https://github.com/PimpDiCaprio/PiQR.git
    ```
  * Installing with pip
    ```sh
    pip install PiQR
    ```



  * How to run the program
  * Step-by-step bullets
  ```
  from PiQR import PiQR


  qr_string = 'Test Input'


  qr_output = PiQR.generate_qr(qr_string, correction_level='Medium')




  PiQR.show_png(qr_output)


  PiQR.make_png(qr_output, 'test.png')


  PiQR.write_ps(qr_output, 'test.ps')


  ps_string = PiQR.return_ps(qr_output)

  ```



    PimpDiCaprio
    info@aperturesoftware.us



  * 0.1.1
      * Import Name Fixes
  * 0.1.0
      * Initial Release
  * 0.1.2
      * Update to module size designation in qr_ps
  * 0.1.3
      * Fixed broken byte conversion for Alphanumeric QR generation



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



  Inspiration, code snippets, etc.
  * [Thonky's QR Code Tutorial](https://www.thonky.com/qr-code-tutorial/introduction)
  * [General Resource QR Wiki](https://en.wikipedia.org/wiki/QR_code)
  * [QR Creation Tool with Steps](https://www.nayuki.io/page/creating-a-qr-code-step-by-step)


pkgId: dc772625151faca1883974fa433d772755ffd0ce8377ccec3edd0aec0f8d2d66
name: python-Plone-help
arch: noarch
version: 6.0.14
epoch: 0
release: 1
summary: Development documents and examples for Plone
url: https://plone.org
rpm_license: GPL version 2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Plone-6.0.14-1.src.rpm
location_href: Packages/python-Plone-help-6.0.14-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
      <img alt="Plone Logo" width="200px" src="https://raw.githubusercontent.com/plone/.github/main/plone-logo.png">
  </p>

  <h1 align="center">
    Plone
  </h1>

  <div align="center">

  [![PyPI - Wheel](https://img.shields.io/pypi/wheel/plone)](https://pypi.org/project/plone/)
  [![PyPI - License](https://img.shields.io/pypi/l/plone)](https://pypi.org/project/plone/)
  [![PyPI - Status](https://img.shields.io/pypi/status/plone)](https://pypi.org/project/plone/)

  [![GitHub contributors](https://img.shields.io/github/contributors/plone/Products.CMFPlone)](https://github.com/plone/Products.CMFPlone)
  ![GitHub Repo stars](https://img.shields.io/github/stars/plone/Plone?style=flat-square)

  </div>

  Plone is a mature, secure, and user-friendly content management system (CMS).

  Plone was first released to the public on October 4, 2001.

  Plone has the maturity, stability, and reliability of an application maintained by open source developers with decades of experience, while continually evolving and adapting to modern technology.

  Lots of customizations can be made trough-the-web, such as creating content types, themes, workflows, and much more.
  Plone may be extended and used as a framework on which to build custom CMS-like solutions.

  Plone works as a

  - Full-featured server-side rendered HTML CMS.
  - React-based frontend for editing and viewing content, backed by a server with a REST API.
  - Headless CMS server with a REST API, allowing a developer to build a custom frontend with their chosen technology.


  <h2 align="center">
    Installing Plone
  </h2>

  Plone is available on Linux, Microsoft Windows, macOS, and BSD platforms.

  Plone may be run as a container in the cloud with Docker and other Open Containers Initiative compliant platforms.
  [Example Dockerfiles](https://6.docs.plone.org/install/containers/images/index.html) and base images are available.

  [Install Plone by choosing an option from plone.org](https://plone.org/download)


  <h2 align="center">
    Documentation
  </h2>

  Consult [the official Plone documentation](https://docs.plone.org) with information for different audiences.

  For trainings [comprehensive Plone training material](https://training.plone.org) is available.


  <h2 align="center">
    What is Plone?
  </h2>

  Plone is a ready-to-run content management system, offering a complete set of features needed by a wide variety of organizations.

  Security is built into Plone's architecture from the ground up.
  Plone offers fine-grained permission control over content and actions.

  Plone is easy to set up, extremely flexible,
  and provides you with a system for managing web content that is ideal for project groups, communities, websites, extranets, and intranets.

  - **Plone is easy to install.**
    Several installation options are available for either your local machine or on servers in the cloud.

  - **Plone empowers content editors and web application developers.**
    The Plone Team includes usability experts who have made Plone easy and attractive for content managers to add, update, and maintain content.

  - **Plone is international.**
    The Plone interface has more than 35 translations, and tools exist for managing multilingual content.

  - **Plone follows standards and is inclusive.**
    Plone carefully follows standards for usability and accessibility.
    Plone is compliant with WCAG 2.1 level AA and aims for ATAG 2.0 level AA.

  - **Plone is open source.**
    Plone is licensed under the GNU General Public License, the same license used by Linux.
    This gives you the right to use Plone without a license fee, and to improve upon the product.

  - **Plone is supported.**
    There are over two hundred active developers in the Plone Development Team around the world, and a multitude of companies that specialize in Plone development and support.

  - **Plone is extensible.**
    There is a multitude of add-on products for Plone to add new features and content types.
    In addition, Plone can be scripted using web standard solutions and open source languages.

  - **Plone is technology neutral.**
    Plone can interoperate with most relational database systems—both open source and commercial—and runs on a vast array of
    platforms, including Linux, Windows, macOS, and BSD.


  <h2 align="center">
  Technical overview
  </h2>

  Plone is a content management platform with its backend written in Python.
  Plone has a choice of frontend, either Classic UI using server-side templates or Volto written in modern React-based JavaScript.
  It builds upon Zope, an open source web application server and development system, and thus on the pluggable Zope Component Architecture (ZCA).

  Python is the easy to learn, widely used, and supported open source programming language.
  Python can be used to add new features to Plone and used to understand or make changes to the way that Plone works.

  Plone stores its contents in Zope's built-in transactional hierarchical object database, the ZODB.
  The ZODB can be connected to simple file-storages, scalable ZEO-Servers or Postgres, MySQL, and Oracle.
  There are add-ons and techniques, however, to share information with other sources, such as relational databases, LDAP, filesystem
  files, and so on.


  <h2 align="center">
  Official Resources
  </h2>

  * [plone.org](https://plone.org/) - Official website for developers, community, decision makers, and evaluators.
  * [Plone support](https://plone.org/support) - Where to find help.
  * [community.plone.org](https://community.plone.org/) - Official community forum, the best place to get help.
  * [docs.plone.org](https://docs.plone.org/) - Official documentation for developers, integrators, and content editors.
  * [training.plone.org](https://training.plone.org/) - Trainings for developers, integrators, content editors, and designers.
  * [`plone.api`](https://docs.plone.org/develop/plone.api/docs/index.html) - Documentation for `plone.api`.
  * [`plone.restapi`](https://plonerestapi.readthedocs.io/en/latest/) - Documentation for `plone.restapi`.
  * [Discord](https://discord.gg/zFY3EBbjaj) - Official Plone chat, voice, and video service.

  <h2 align="center">
  This project is supported by
  </h2>

  <p align="center">
      <a href="https://plone.org/foundation/">
        <img alt="Plone Logo" width="200px" src="https://raw.githubusercontent.com/plone/.github/main/plone-foundation.png">
      </a>
  </p>

  <h2 align="center">
  License
  </h2>
  The project is licensed under the GPLv2.






  Bug fixes:

  - Release 6.0.14.
    [maurits]





  Bug fixes:

  - Release 6.0.13.
    [maurits]





  Bug fixes:

  - Release 6.0.12.
    [maurits]





  Bug fixes:

  - Release 6.0.11.
    [maurits]




  Bug fixes:

  - Release 6.0.10.
    [maurits]





  Bug fixes:

  - Release 6.0.9.
    [maurits]




  Bug fixes:

  - Release 6.0.8.
    [maurits]




  Bug fixes:

  - Release 6.0.7.
    [maurits]




  Bug fixes:

  - Release 6.0.6.
    [maurits]




  Bug fixes:

  - Release 6.0.5.
    [maurits]




  Bug fixes:

  - Release 6.0.4.
    [maurits]




  Bug fixes:

  - Release 6.0.3.
    [maurits]





  Bug fixes:

  - Release 6.0.2.
    [maurits]





  Bug fixes:

  - Release 6.0.1.
    [maurits]




  Bug fixes:

  - Release 6.0.0 final.
    [maurits]




  Bug fixes:

  - Release 6.0.0rc2.
    [maurits]

  Internal:

  - Improve metadata on pypi.org
    [ericof]




  Bug fixes:

  - Release 6.0.0rc1.
    [maurits]




  Bug fixes:

  - Release 6.0.0b3.
    [maurits]




  Breaking changes:

  - Officially drop Python 3.7 support and add 3.10 support.
    Currently everything still work in 3.7, but beta 2 is the last release where this is the case.
    [maurits]




  Bug fixes:

  - Release 6.0.0b1.
    [maurits]




  Bug fixes:

  - Release 6.0.0a6.
    [maurits]




  Bug fixes:

  - Release 6.0.0a5.
    [maurits]




  New features:

  - Depend on ``plone.volto``.
    [maurits]




  Bug fixes:

  - Release 6.0.0a3.
    [maurits]




  Bug fixes:

  - Release 6.0.0a2.
    [maurits]




  Bug fixes:

  - Release 6.0.0a1.dev1.
    Update: accidentally released as 6.0.0a1.
    [maurits]




  Breaking changes:

  - Remove ``archetypes`` extra in ``setup.py``.
    [jensens]

  - Drop Python 2 support.
    [jensens]

  Misc:

  - Create internal release on dist.plone.org.  [maurits]

  - Move ``setup.py`` metadata to ``setup.cfg``.
    [jensens]




  Bug fixes:

  - Release Plone 5.2.5 final
    [maurits]




  Bug fixes:

  - Release Plone 5.2.4 final
    [maurits]

  - Removed ``plone.app.dexterity`` from dependencies.
    It is already required by ``Products.CMFPlone``.
    [maurits]




  Bug fixes:

  - Release Plone 5.2.3 final
    [maurits]




  New features:

  - Release Plone 5.2.2 final
    [maurits]




  New features:

  - Release Plone 5.2.1 final
    [esteele]





  New features:

  - Release Plone 5.2 final
    [esteele]




  New features:

  - Release Plone 5.2rc5
    [esteele]




  New features:

  - Release Plone 5.2rc4
    [esteele]




  New features:

  - Release Plone 5.2rc3
    [esteele]




  Bug fixes:

  - Release Plone 5.2rc2
    [esteele]



  New features:

  - Release Plone 5.2rc1
    [esteele]




  New features:

  - Add plone.restapi as a dependency.
    [timo]




  New features:

  - Release Plone 5.2a2
    [esteele]




  New features:

  - Release Plone 5.2a1
    [esteele]




  New features:

  - Release Plone 5.1.4
    [esteele]




  New features:

  - Release Plone 5.1.3
    [esteele]




  New features:

  - Release Plone 5.1.2
    [esteele]




  New features:

  - Release Plone 5.1.1
    [esteele]




  New features:

  - Release Plone 5.1
    [esteele]




  New features:

  - Release Plone 5.1rc2
    [esteele]



  New features:

  - Release Plone 5.1rc1





  New features:

  - Release Plone 5.1b4
    [esteele]

  Bug fixes:

  - Add link to Plone.com and tweak intro
    [tkimnguyen]



  New features:

  - Release Plone 5.1b3
    [esteele]




  New features:

  - Release Plone 5.1b2
    [esteele]




  Breaking changes:

  - Remove plone.app.openid from core, still available as addon package.
    [jensens]

  New features:

  - Release Plone 5.1b1
    [esteele]

  Bug fixes:

  - Be sure to require archetypes.multilingual
    even if it's not required as a dependency of plone.app.multilingual.
    [davisagli]




  New:

  - Release Plone 5.1a2
    [esteele]




  New:

  - Release Plone 5.1a1
    [esteele]



  New:

  - Release Plone 5.0.2
    [esteele]




  - Release Plone 5.0.1
    [esteele]




  - Release Plone 5.0
    [esteele]




  - Release Plone 5.0rc3
    [esteele]




  - Release Plone 5.0rc2
    [esteele]




  - Release Plone 5.0rc1
    [esteele]




  - Release Plone 5.0b4
    [esteele]




  - Release Plone 5.0b3
    [esteele]



  - Release Plone 5.0b2
    [esteele]




  - Release Plone 5.0b1
    [esteele]




  - Release Plone 5.0a3
    [esteele]




  - Move plone.app.theming dependency into Products.CMFPlone.
    [esteele]



    - Release Plone 4.3.4 [esteele]




    - Release Plone 4.3.3 [esteele]



    - Release Plone 4.3.2 [esteele]




  - Release Plone 4.3.1
    [esteele]




  - Release Plone 4.3
    [esteele]




  - Release Plone 4.3b2
    [esteele]




  - Release Plone 4.3b1
    [esteele]




  - Release Plone 4.3a2
    [esteele]




  - Release Plone 4.3a1
    [esteele]




  - Release Plone 4.2.1
    [esteele]




  - Release Plone 4.2
    [esteele]




  - Release Plone 4.2rc2
    [esteele]

  - Add explicit dependencies on some `zope.app` libraries, to ensure they
    stay included during the 4.2 series.
    [hannosch]




  - Release Plone 4.2rc1
    [esteele]




  - Release Plone 4.2b2
    [esteele]




  - Release Plone 4.2b1
    [esteele]



  - Release Plone 4.2a2
    [esteele]



  - Release Plone 4.2a1
    [esteele]



  - Release Plone 4.1 final
    [esteele]



  - Release Plone 4.1rc3
    [esteele]



  - Release Plone 4.1rc2
    [esteele]




  - Release Plone 4.1rc1
    [esteele]



  - Release Plone 4.1b2
    [esteele]

  - Depend on wicked now that Products.CMFPlone doesn't.
    [davisagli]



  - Release Plone 4.1b1
    [esteele]



  - Release Plone 4.1a3
    [esteele]



  - Include plone.app.caching as an optional, shipped add-on.
    [esteele]



  - Separate `Products.CMFPlone` from the `Plone` egg.
    [elro]


pkgId: c66008d69f466279a3dd9ab0c654c170a813e20247958fe92bf221267b732111
name: python-PolUVR-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for PolUVR
url: https://github.com/Bebra777228/PolUVR
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PolUVR-1.2.0-1.src.rpm
location_href: Packages/python-PolUVR-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  **Supported CUDA Versions:** 11.8 and 12.2
  To verify successful configuration, run `PolUVR --env_info`. You should see the following log message:
  ```
  ONNXruntime has CUDAExecutionProvider available, enabling acceleration
  ```
  **Installation:**
  ```sh
  pip install "PolUVR[gpu]"
  ```

  To verify successful configuration, run `PolUVR --env_info`. You should see the following log message:
  ```
  ONNXruntime has CoreMLExecutionProvider available, enabling acceleration
  ```
  **Installation:**
  ```sh
  pip install "PolUVR[cpu]"
  ```

  **Installation:**
  ```sh
  pip install "PolUVR[cpu]"


pkgId: 4d190f3e1b2fec5ee7881766b8a1f274df42c30ed3a04eb0b5ee3ab76c0bc342
name: python-Prompete-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for Prompete
url: https://github.com/zby/Prompete
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Prompete-0.0.5-1.src.rpm
location_href: Packages/python-Prompete-help-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
  Prompete is a wrapper for LiteLLM.
  It integrates LLMEasyTools, and Jinja2 templates to create a flexible system for
  managing prompts and chat interactions. Part of the API is inspired by Claudette.


  The key idea behind Prompete is that LLM prompts contain two distinct components:
  - data: the information that the LLM is supposed to manipulate
  - instructions: the instructions on how to interpret and use that data

  These two parts have different nature, and are manipulated differently.
  They change in different rythms and in different phases of the project. They are
  edited in different ways and mixing them together is error prone and makes the
  prompt management harder. For example long text blocks in code demolish the
  visual clues a programmer relies on when reading that code.

  Prompete tries to address this by separating the two components into data structures and
  templates.

  But that does not mean that when using Prompete you need to start immediately with
  templated prompts. You can start working in Prompete with simple string prompts,
  then progressively adopt more advanced features as your needs evolve.



  - Template-based prompt generation using Jinja2
  - Integration with various LLM APIs through LiteLLM
  - Emulate `response_format` by using `tools` (for models that don't support `response_format`)
  - Easy function calling with LLMEasyTools
  - Conversation management with the Chat interface
  - System prompts and custom prompt roles



  Install Prompete using pip:

  ```bash
  pip install prompete
  ```



  First you need to set up your API credentials in your environment variables.
  Depending on the model you choose, you'll need to set:
  - OPENAI_API_KEY for OpenAI models
  - ANTHROPIC_API_KEY for Anthropic models

  For example:
  ```bash
  export OPENAI_API_KEY='your-openai-api-key-here'
  ```




  ```python
  from prompete import Chat

  model = "gpt-4o-mini"  # OpenAI model


  chat = Chat(
      model=model,
      system_prompt="You are a helpful assistant specializing in Python programming."
  )


  user_message = "What's the difference between a list and a tuple in Python?"
  response = chat(user_message)

  print("User:", user_message)
  print("AI:", response)
  ```



  A full example of templating with Prompete can be found in the `examples/templating.py` file.

  To use templating with Prompete, you need to create a Jinja2 Environment.
  You can use all features of Jinja2 like multiple directories to search for template files, add
  custom filters, etc.

  ```python

  renderer = Environment(
      loader=ChoiceLoader([
          FileSystemLoader(os.path.join(current_dir, "templates")),
      ])
  )
  ```

  The data is passed to the template as a subclass of `Prompt`.

  ```python
  @dataclass(frozen=True)
  class TaskPrompt(Prompt):
      user_name: str
      language: str
      task: str

  task_prompt = TaskPrompt(
      user_name="Alice",
      language="Python",
      task="write a function to calculate the factorial of a number"
  )

  print(chat(task_prompt))
  ```

  The prompt tempalte is found by looking up the class name in the templates defined in the renderer.
  The template can use the prompt fields as variables.



  Prompete integrates with LLMEasyTools to provide function calling capabilities.
  Here's how it works:



  ```python
  from prompete import Chat

  def get_weather(location: str, unit: str = "celsius") -> dict:
      """Get the current weather in a given location"""
      
      return {
          "location": location,
          "temperature": 22,
          "unit": unit,
          "forecast": ["sunny", "windy"],
      }

  chat = Chat(model="gpt-4")
  response = chat("Should I bring an umbrella to London today?", tools=[get_weather])
  print(tool_results)
  ```



  When working with function calls, there are two main approaches to handle the results:

  1. **LLM Interpretation**: Let the LLM interpret the tool results and provide a human-friendly response
  ```python

  chat = Chat(model="gpt-4")
  response = chat("Should I bring an umbrella to London today?", tools=[get_weather])
  print(response)  # LLM provides a natural language response based on the weather data
  ```
  The pitfall of this more 'agentic' approach is that the LLM can sometimes decide
  to guess the weather instead of calling the function.

  2. **Direct Code Processing**: Handle the tool results directly in your code
  ```python

  chat = Chat(model="gpt-4")
  chat.append("What's the weather in London?")
  response, tool_results = chat.complete_once(tools=[get_weather])

  if tool_results:
      weather_data = tool_results[0]
      print(f"Temperature: {weather_data['temperature']}°{weather_data['unit']}")
  ```



  There are two ways to control tool execution loops:

  - `max_llm_requests`: - parameter to `__call__` - limits how many LLM request can be made in a single conversation turn
      - default is 2 - first request to generate a tool call message - second one to interpret the tool call results
      if the LLM does not return a tool call message, the second request will be skipped
      you can set it to more than 2 if you want the LLM to try tool execution untill it gets the results it needs
  - `tool_choice`: - parameter to `__call__` and `compelete_once` passed to LiteLLM - you can use it to force the LLM to use a specific tool




  All tool calls and their results are automatically saved in the chat history, making them available for context in future conversation turns.



  - **Chat**: The main class for managing conversations and interacting with LLMs.
  - **Prompt**: Base class for creating custom prompt types.
  - **renderer**: Jinja2 Environment for rendering prompts with dynamic content.



  We welcome contributions to Prompete! Please follow these steps:

  1. Fork the repository
  2. Create a new branch for your feature or bug fix
  3. Make your changes and write tests if applicable
  4. Submit a pull request with a clear description of your changes

  For major changes, please open an issue first to discuss the proposed changes.



  We strongly encourage writing test cases for both bug reports and feature requests:

  - For bugs: Include a test case that reproduces the issue, showing expected vs. actual behavior.
  - For features: Provide test cases describing the desired functionality, including inputs and expected outputs.




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



  If you encounter any issues or have questions, please [open an issue](https://github.com/zby/prompete/issues) on our GitHub repository.



  Prompete is built upon several excellent libraries:

  - [LiteLLM](https://github.com/BerriAI/litellm) for universal LLM API support
  - [Jinja2](https://jinja.palletsprojects.com/) for powerful templating capabilities
  - [Claudette](https://claudette.answer.ai/) for the API inspiration

  We're grateful to the maintainers and contributors of these projects.

rpm_license:
  MIT License  Copyright (c) 2024 Your Name  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: 24b95f83bf6a0dce205091cc6c80e77405389c90e56d7728d1f77d9d4dcae262
name: python-PullDocker-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for PullDocker
url: http://www.muflone.com/pulldocker/
rpm_license: GPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PullDocker-0.3.0-1.src.rpm
location_href: Packages/python-PullDocker-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  NAME: PixelColor
  REPOSITORY_DIR: /home/muflone/pixelcolor.git
  REMOTES:
    - github
  ```
  The first repository will monitor the `origin` remote and the second repository
  will monitor the `github` remote.

  The following YAML specifications
  ```yaml
  NAME: Repository name
  REPOSITORY_DIR: <Path where the git repository is cloned and can be pull>
  REMOTES:
    - origin
    - github
    - gitlab
  TAGS: '*'
  COMPOSE_FILE: docker/docker-compose.yaml
  DETACHED: true
  BUILD: true
  RECREATE: true
  COMMAND: docker compose -f docker/docker-compose.yaml up -d
  BEGIN:
    - bash -c 'echo BEGIN ${DATE} ${TIME}'
  BEFORE:
    - bash -c 'echo BEFORE ${DATE} ${TIME}'
    - bash -c 'echo ${TAG} ${TAG_HASH} ${TAG_DATE} ${TAG_TIME}'
  AFTER:
    - bash -c 'echo AFTER ${DATE} ${TIME}'
    - bash -c 'echo ${TAG} ${TAG_HASH} ${TAG_DATE} ${TAG_TIME}'
  END:
    - bash -c 'echo END ${DATE} ${TIME}'
  ```
  The `TAGS` argument can be used to deploy the update only when the latest
  commit matches a tag. The tag specification can be `'*'` to indicate any tag
  available or a *regex* (Regular expression) can be used to match the available
  tags. For example the following: `TAGS: '0\.[1-9]\.*'` will only match the
  tags starting with 0.1.x up to 0.9.x and it would exclude the tags with 0.0.x.
  If no tags are specified, any available commit newer than the current commit
  will issue the deploy.
  The `COMPOSE_FILE` argument is used to specify the path for a
  docker-compose.yaml/yml file in the case the file is contained in another
  directory or it has a different name than the default docker-compose.yaml.
  The `DETACHED` argument is used to specify a boolean value for running the
  docker compose in detached mode (the default, passing `true`) or without the
  detached mode, by specifying the value `false`.
  The `BUILD` argument is used to build the images before starting the deploy.
  The `RECREATE` argument is used to force the recreate the containers even if
  the configuration wasn't changed.
  The `COMMAND` argument can be used to specify the explicit command for the
  deploy, instead of using `docker compose up`. This command will override any
  previous `COMPOSE_FILE`, `DETACHED`, `BUILD` arguments.
  The `BEGIN` argument can be a list of commands to execute when checking the
  status for the repository, regardless if it has updates or not.
  Multiple commands can be specified.
  The `BEFORE` argument can be a list of commands to execute after checking the
  status for the repository, before the deploy is done if it **has updates**.
  Multiple commands can be specified.
  The `AFTER` argument can be a list of commands to execute after checking the
  status for the repository, after the deploy is done if it **has updates**.
  Multiple commands can be specified.
  The `END` argument can be a list of commands to execute after checking the
  status for the repository, regardless if it has updates or not.
  Multiple commands can be specified.

  The commands arguments can use both strings (one command per line) or list of
  arguments (one argument per line) using the YAML lists syntax.
  The following are both valid:
  ```yaml
  BEGIN:
    - bash -c 'echo BEGIN ${DATE} ${TIME}'
  ```
  Using the list syntax:
  ```yaml
  BEGIN:
    -
      - bash
      - -c
      - 'echo BEGIN ${DATE} ${TIME}'
  ```

  The following special variables can be used in any command to replace the
  variable with its value:
  - `${DATE}`: current date with the format YYYY-MM-DD
  - `${TIME}`: current time with the format HH:mm:ss
  - `${COMMIT_HASH}`: latest commit hash
  - `${COMMIT_DATE}`: latest commit date with the format YYYY-MM-DD
  - `${COMMIT_TIME}`: latest commit with the format HH:mm:ss
  - `${COMMIT_BRANCH}`: latest commit branch name
  - `${COMMIT_AUTHOR}`: latest commit author name
  - `${COMMIT_EMAIL}`: latest commit author email
  - `${COMMIT_MESSAGE}`: latest commit message
  - `${COMMIT_SUMMARY}`: latest commit summary
  The following variables can only be used for the `COMMAND`, `BEFORE` and
  `AFTER` arguments when the `TAGS` argument is used so their values will refer
  to the matching tag used:
  - `${TAG}`: tag name
  - `${TAG_HASH}`: commit hash for the matching tag
  - `${TAG_AUTHOR}`: commit author name for the matching tag
  - `${TAG_EMAIL}`: commit author email for the matching tag
  - `${TAG_MESSAGE}`: tag message
  - `${TAG_SUMMARY}`: commit message for the matching tag
  - `${TAG_DATE}`: tag date with the format YYYY-MM-DD
  - `${TAG_TIME}`: tag time with the format HH:mm:ss


pkgId: 26b1ba6ab858cec3eab758bdb72d86ed7f0fb84e76a89f3555c96fa0e277112c
name: python-PyAibote-help
arch: noarch
version: 1.7.7
epoch: 0
release: 1
summary: Development documents and examples for PyAibote
url: https://www.pyaibote.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyAibote-1.7.7-1.src.rpm
location_href: Packages/python-PyAibote-help-1.7.7-1.noarch.rpm
checksum_type: sha256
description:
  Support Android native APP and H5 interface elements and color positioning. The speed of element location is 10 times that of Appium framework, and the color location of 2340*1080 image only takes 50 milliseconds, It supports the positioning of window interface elements and colors developed by Windows applications,. NET, WinForm, WPF, QT, Java (GUI libraries such JAVA(Swing and AWT) and Electron. The exclusive xpath algorithm is concise and rapid, and the positioning speed of elements/colors is 3 times and 20 times that of visual RPA, respectively, All browsers and applications that support the chromium kernel. A web automation framework developed by C/C++ language based on browser kernel protocol. Ten times faster than Selenium


pkgId: c9c8df68ff19b800fed77d0a9b06374e9982d96d6f3c5698337f5f2ad63975c8
name: python-PyBIS-help
arch: noarch
version: 1.37.0
epoch: 0
release: 1
summary: Development documents and examples for PyBIS
url: https://sissource.ethz.ch/sispub/openbis/tree/master/pybis
rpm_license: Apache Software License Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyBIS-1.37.0-1.src.rpm
location_href: Packages/python-PyBIS-help-1.37.0-1.noarch.rpm
checksum_type: sha256
description:
  pyBIS is a Python module for interacting with openBIS. pyBIS is designed to be most useful in a [Jupyter Notebook](https://jupyter.org) or IPython environment, especially if you are developing Python scripts for automatisation. Jupyter Notebooks offer some sort of IDE for openBIS, supporting TAB completition and immediate data checks, making the life of a researcher hopefully easier.



  - pyBIS relies the openBIS API v3
  - openBIS version 16.05.2 or newer is required
  - 19.06.5 or later is recommended
  - pyBIS uses Python 3.6 or newer and the Pandas module



  ```
  pip install --upgrade pybis
  ```

  That command will download install pyBIS and all its dependencies. If pyBIS is already installed, it will be upgraded to the latest version.

  If you haven't done yet, install Jupyter and/or Jupyter Lab (the next Generation of Jupyter):

  ```
  pip install jupyter
  pip install jupyterlab
  ```





  - in a Jupyter Notebook or IPython environment, pybis helps you to enter the commands
  - After every dot `.` you might hit the `TAB` key in order to look at the available commands.
  - if you are unsure what parameters to add to a , add a question mark right after the method and hit `SHIFT+ENTER`
  - Jupyter will then look up the signature of the method and show some helpful docstring



  - When working with properties of entities, they might use a **controlled vocabulary** or are of a specific **property type**.
  - Add an underscore `_` character right after the property and hit `SHIFT+ENTER` to show the valid values
  - When a property only acceps a controlled vocabulary, you will be shown the valid terms in a nicely formatted table
  - if you try to assign an **invalid value** to a property, you'll receive an error immediately



  - **spaces:** used for authorisation eg. to separate two working groups. If you have permissions in a space, you can see everything which in that space, but not necessarily in another space (unless you have the permission).
  - **projects:** a space consists of many projects.
  - **experiments / collections:** a projects contain many experiments. Experiments can have _properties_
  - **samples / objects:** an experiment contains many samples. Samples can have _properties_
  - **dataSet:** a dataSet which contains the actual _data files_, either pyhiscal (stored in openBIS dataStore) or linked
  - **attributes:** every entity above contains a number of attributes. They are the same accross all instances of openBIS and independent of their type.
  - **properties:** Additional specific key-value pairs, available for these entities:

    - experiments
    - samples
    - dataSets

    every single instance of an entity must be of a specific **entity type** (see below). The type defines the set of properties.

  - **experiment type / collection type:** a type for experiments which specifies its properties
  - **sample type / object type:** a type for samples / objects which specifies its properties
  - **dataSet type:** a type for dataSets which specifies its properties
  - **property type:** a single property, as defined in the entity types above. It can be of a classic data type (e.g. INTEGER, VARCHAR, BOOLEAN) or its values can be controlled (CONTROLLEDVOCABULARY).
  - **plugin:** a script written in [Jython](https://www.jython.org) which allows to check property values in a even more detailed fashion





  In an **interactive session** e.g. inside a Jupyter notebook, you can use `getpass` to enter your password safely:

  ```
  from pybis import Openbis
  o = Openbis('https://example.com')
  o = Openbis('example.com')          # https:// is assumed

  import getpass
  password = getpass.getpass()

  o.login('username', password, save_token=True)   # save the session token in ~/.pybis/example.com.token
  ```

  In a **script** you would rather use two **environment variables** to provide username and password:

  ```
  from pybis import Openbis
  o = Openbis(os.environ['OPENBIS_HOST'])

  o.login(os.environ['OPENBIS_USERNAME'], os.environ['OPENBIS_PASSWORD'])
  ```



  By default, your SSL-Certification is being verified. If you have a test-instance with a self-signed certificate, you'll need to turn off this verification explicitly:

  ```python
  from pybis import Openbis
  o = Openbis('https://test-openbis-instance.com', verify_certificates=False)
  ```



  Check whether your session, i.e. the **session token** is still valid and log out:

  ```python
  print(f"Session is active: {o.is_session_active()} and token is {o.token}")
  o.logout()
  print(f"Session is active: {o.is_session_active()"}
  ```



  With `pyBIS 1.17.0`, a lot of caching has been introduced to improve the speed of object lookups that do not change often. If you encounter any problems, you can turn it off like this:

  ```python
  o = Openbis('https://example.com', use_cache=False)


  o.use_cache = False
  o.clear_cache()
  o.clear_cache('sampleType')
  ```





  Mounting an openBIS dataStore server requires FUSE / SSHFS to be installed (requires root privileges). The mounting itself requires no root privileges.

  **Mac OS X**

  Follow the installation instructions on
  https://osxfuse.github.io

  **Unix Cent OS 7**

  ```
  $ sudo yum install epel-release
  $ sudo yum --enablerepo=epel -y install fuse-sshfs
  $ user="$(whoami)"
  $ usermod -a -G fuse "$user"
  ```

  After the installation, an `sshfs` command should be available.



  Because the mount/unmount procedure differs from platform to platform, pyBIS offers two simple methods:

  ```
  o.mount()
  o.mount(username, password, hostname, mountpoint, volname)
  o.is_mounted()
  o.unmount()
  o.get_mountpoint()
  ```

  Currently, mounting is supported for Linux and Mac OS X only.

  All attributes, if not provided, are re-used by a previous login() command. If no mountpoint is provided, the default mounpoint will be `~/hostname`. If this directory does not exist, it will be created. The directory must be empty before mounting.



  OpenBIS stores quite a lot of meta-data along with your dataSets. The collection of data that describes this meta-data (i.e. meta-meta-data) is called masterdata. It consists of:

  - sample types
  - dataSet types
  - material types
  - experiment types
  - property types
  - vocabularies
  - vocabulary terms
  - plugins (jython scripts that allow complex data checks)
  - tags
  - semantic annotations



  ```
  sample_types = o.get_sample_types()  # get a list of sample types
  sample_types.df                      # DataFrame object
  st = o.get_sample_types()[3]         # get 4th element of that list
  st = o.get_sample_type('YEAST')
  st.code
  st.generatedCodePrefix
  st.attrs.all()                       # get all attributes as a dict
  st.get_validationPlugin()            # returns a plugin object

  st.get_property_assignments()        # show the list of properties
                                       
  o.get_material_types()
  o.get_dataset_types()
  o.get_experiment_types()
  o.get_collection_types()

  o.get_property_types()
  pt = o.get_property_type('BARCODE_COMPLEXITY_CHECKER')
  pt.attrs.all()

  o.get_plugins()
  pl = o.get_plugin('Diff_time')
  pl.script  # the Jython script that processes this property

  o.get_vocabularies()
  o.get_vocabulary('BACTERIAL_ANTIBIOTIC_RESISTANCE')
  o.get_terms(vocabulary='STORAGE')
  o.get_tags()
  ```



  **Samples** (objects), **experiments** (collections) and **dataSets** contain type-specific **properties**. When you create a new sample, experiment or datasSet of a given type, the set of properties is well defined. Also, the values of these properties are being type-checked.

  The first step in creating a new entity type is to create a so called **property type**:

  ```
  pt_text = o.new_property_type(
      code        = 'MY_NEW_PROPERTY_TYPE',
      label       = 'yet another property type',
      description = 'my first property',
      dataType    = 'VARCHAR',
  )
  pt_text.save()

  pt_int = o.new_property_type(
      code        = 'MY_NUMBER',
      label       = 'property contains a number',
      dataType    = 'INTEGER',
  )
  pt_int.save()

  pt_voc = o.new_property_type(
      code        = 'MY_CONTROLLED_VOCABULARY',
      label       = 'label me',
      description = 'give me a description',
      dataType    = 'CONTROLLEDVOCABULARY',
      vocabulary  = 'STORAGE',
  )
  pt_voc.save()

  pt_richtext = o.new_property_type(
      code        = 'MY_RICHTEXT_PROPERTY',
      label       = 'richtext data',
      description = 'property contains rich text',
      dataType    = 'MULTILINE_VARCHAR',
      metaData    = {'custom_widget' : 'Word Processor'}
  )
  pt_richtext.save()

  pt_spread = o.new_property_type(
      code        = 'MY_TABULAR_DATA',
      label       = 'data in a table',
      description = 'property contains a spreadsheet',
      dataType    = 'XML',
      metaData    = {'custom_widget': 'Spreadsheet'}
  )
  pt_spread.save()
  ```

  The `dataType` attribute can contain any of these values:

  - `INTEGER`
  - `VARCHAR`
  - `MULTILINE_VARCHAR`
  - `REAL`
  - `TIMESTAMP`
  - `BOOLEAN`
  - `HYPERLINK`
  - `XML`
  - `CONTROLLEDVOCABULARY`
  - `MATERIAL`

  When choosing `CONTROLLEDVOCABULARY`, you must specify a `vocabulary` attribute (see example). Likewise, when choosing `MATERIAL`, a `materialType` attribute must be provided.

  To create a **richtext property**, use `MULTILINE_VARCHAR` as `dataType` and set `metaData` to `{'custom_widget' : 'Word Processor'}` as shown in the example above.

  To create a **tabular, spreadsheet-like property**, use `XML` as `dataType` and set `metaData` to `{'custom_widget' : 'Spreadhseet'}`as shown in the example above.

  **Note**: PropertyTypes that start with a \$ are by definition `managedInternally` and therefore this attribute must be set to True.



  The second step (after creating a property type, see above) is to create the **sample type**. The new name for **sample** is **object**. You can use both methods interchangeably:

  - `new_sample_type()` == `new_object_type()`

  ```
  sample_type = o.new_sample_type(
      code                = 'my_own_sample_type',  # mandatory
      generatedCodePrefix = 'S',                   # mandatory
      description         = '',
      autoGeneratedCode   = True,
      subcodeUnique       = False,
      listable            = True,
      showContainer       = False,
      showParents         = True,
      showParentMetadata  = False,
      validationPlugin    = 'Has_Parents'          # see plugins below
  )
  sample_type.save()
  ```



  The third step, after saving the sample type, is to **assign or revoke properties** to the newly created sample type. This assignment procedure applies to all entity types (dataset type, experiment type).

  ```
  sample_type.assign_property(
  	prop                 = 'diff_time',           # mandatory
  	section              = '',
  	ordinal              = 5,
  	mandatory            = True,
  	initialValueForExistingEntities = 'initial value'
  	showInEditView       = True,
  	showRawValueInForms  = True
  )
  sample_type.revoke_property('diff_time')
  sample_type.get_property_assignments()
  ```



  The second step (after creating a **property type**, see above) is to create the **dataset type**. The third step is to **assign or revoke the properties** to the newly created dataset type.

  ```
  dataset_type = o.new_dataset_type(
      code                = 'my_dataset_type',       # mandatory
      description         = None,
      mainDataSetPattern  = None,
      mainDataSetPath     = None,
      disallowDeletion    = False,
      validationPlugin    = None,
  )
  dataset_type.save()
  dataset_type.assign_property('property_name')
  dataset_type.revoke_property('property_name')
  dataset_type.get_property_assignments()
  ```



  The second step (after creating a **property type**, see above) is to create the **experiment type**.

  The new name for **experiment** is **collection**. You can use both methods interchangeably:

  - `new_experiment_type()` == `new_collection_type()`

  ```
  experiment_type = o.new_experiment_type(
      code,
      description      = None,
      validationPlugin = None,
  )
  experiment_type.save()
  experiment_type.assign_property('property_name')
  experiment_type.revoke_property('property_name')
  experiment_type.get_property_assignments()
  ```



  Materials and material types are deprecated in newer versions of openBIS.

  ```
  material_type = o.new_material_type(
      code,
      description=None,
      validationPlugin=None,
  )
  material_type.save()
  material_type.assign_property('property_name')
  material_type.revoke_property('property_name')
  material_type.get_property_assignments()

  ```



  Plugins are Jython scripts that can accomplish more complex data-checks than ordinary types and vocabularies can achieve. They are assigned to entity types (dataset type, sample type etc). [Documentation and examples can be found here](https://wiki-bsse.ethz.ch/display/openBISDoc/Properties+Handled+By+Scripts)

  ```
  pl = o.new_plugin(
      name       ='my_new_entry_validation_plugin',
      pluginType ='ENTITY_VALIDATION',       # or 'DYNAMIC_PROPERTY' or 'MANAGED_PROPERTY',
      entityKind = None,                     # or 'SAMPLE', 'MATERIAL', 'EXPERIMENT', 'DATA_SET'
      script     = 'def calculate(): pass'   # a JYTHON script
  )
  pl.save()
  ```



  Users can only login into the openBIS system when:

  - they are present in the authentication system (e.g. LDAP)
  - the username/password is correct
  - the user's mail address needs is present
  - the user is already added to the openBIS user list (see below)
  - the user is assigned a role which allows a login, either directly assigned or indirectly assigned via a group membership

  ```
  o.get_groups()
  group = o.new_group(code='group_name', description='...')
  group = o.get_group('group_name')
  group.save()
  group.assign_role(role='ADMIN', space='DEFAULT')
  group.get_roles()
  group.revoke_role(role='ADMIN', space='DEFAULT')

  group.add_members(['admin'])
  group.get_members()
  group.del_members(['admin'])
  group.delete()

  o.get_persons()
  person = o.new_person(userId='username')
  person.space = 'USER_SPACE'
  person.save()


  person.assign_role(role='ADMIN', space='MY_SPACE')
  person.assign_role(role='OBSERVER')
  person.get_roles()
  person.revoke_role(role='ADMIN', space='MY_SPACE')
  person.revoke_role(role='OBSERVER')

  o.get_role_assignments()
  o.get_role_assignments(space='MY_SPACE')
  o.get_role_assignments(group='MY_GROUP')
  ra = o.get_role_assignment(techId)
  ra.delete()
  ```



  Spaces are fundamental way in openBIS to divide access between groups. Within a space, data can be easily shared. Between spaces, people need to be given specific access rights (see section above). The structure in openBIS is as follows:

  - space
    - project
      - experiment / collection
        - sample / object
          - dataset

  ```
  space = o.new_space(code='space_name', description='')
  space.save()
  o.get_spaces(
      start_with = 0,                   # start_with and count
      count      = 10,                  # enable paging
  )
  space = o.get_space('MY_SPACE')


  space.code
  space.description
  space.registrator
  space.registrationDate
  space.modifier
  space.modificationDate



  space.description = '...'


  space.attrs.all()

  space.delete('reason for deletion')
  ```



  Projects live within spaces and usually contain experiments (aka collections):

  - space
    - project
      - experiment / collection
        - sample / object
          - dataset

  ```
  project = o.new_project(
      space       = space,
      code        = 'project_name',
      description = 'some project description'
  )
  project = space.new_project(
  	code         = 'project_code',
  	description  = 'project description'
  )
  project.save()

  o.get_projects(
      space       = 'MY_SPACE',         # show only projects in MY_SPACE
      start_with  = 0,                  # start_with and count
      count       = 10,                 # enable paging
  )
  o.get_projects(space='MY_SPACE')
  space.get_projects()

  project.get_experiments()

  project.get_attachments()             # deprecated, as attachments are not compatible with ELN-LIMS.
                                        
  p.add_attachment(                     # deprecated, see above
      fileName='testfile',
       description= 'another file',
       title= 'one more attachment'
  )
  project.download_attachments(<path or cwd>)  # deprecated, see above


  project.code
  project.description


  project.description = '...'


  project.attrs.all()

  project.freeze = True
  project.freezeForExperiments = True
  project.freezeForSamples = True
  ```



  Experiments live within projects:

  - space
    - project
      - experiment / collection
        - sample / object
          - dataset

  The new name for **experiment** is **collection**. You can use boths names interchangeably:

  - `get_experiment()` = `get_collection()`
  - `new_experiment()` = `new_collection()`
  - `get_experiments()` = `get_collections()`



  ```
  exp = o.new_experiment
      code='MY_NEW_EXPERIMENT',
      type='DEFAULT_EXPERIMENT',
      space='MY_SPACE',
      project='YEASTS'
  )
  exp.save()
  ```



  ```
  experiments = o.get_experiments(
      project       = 'YEASTS',
      space         = 'MY_SPACE',
      type          = 'DEFAULT_EXPERIMENT',
      tags          = '*',
      finished_flag = False,
      props         = ['name', 'finished_flag']
  )
  experiments = project.get_experiments()
  experiment = experiments[0]        # get first experiment of result list
  experiment = experiment
  for experiment in experiments:     # iterate over search results
      print(experiment.props.all())
  dataframe = experiments.df         # get Pandas DataFrame of result list

  exp = o.get_experiment('/MY_SPACE/MY_PROJECT/MY_EXPERIMENT')
  ```



  ```
  exp.attrs.all()                    # returns all attributes as a dict

  exp.attrs.tags = ['some', 'tags']
  exp.tags = ['some', 'tags']        # same thing
  exp.save()

  exp.code
  exp.description
  exp.registrator
  ...

  exp.project = 'my_project'
  exp.space   = 'my_space'
  exp.freeze = True
  exp.freezeForDataSets = True
  exp.freezeForSamples = True

  exp.save()                         # needed to save/update the changed attributes and properties
  ```



  **Getting properties**

  ```
  experiment.props == ds.p                  # you can use either .props or .p to access the properties
  experiment.p                              # in Jupyter: show all properties in a nice table
  experiment.p()                            # get all properties as a dict
  experiment.props.all()                    # get all properties as a dict
  experiment.p('prop1','prop2')             # get some properties as a dict
  experiment.p.get('$name')                 # get the value of a property
  experiment.p['property']                  # get the value of a property
  ```

  **Setting properties**

  ```
  experiment.experiment = 'first_exp'       # assign sample to an experiment
  experiment.project = 'my_project'         # assign sample to a project

  experiment.p. + TAB                       # in Jupyter/IPython: show list of available properties
  experiment.p.my_property_ + TAB           # in Jupyter/IPython: show datatype or controlled vocabulary
  experiment.p['my_property']= "value"      # set the value of a property
  experiment.p.set('my_property, 'value')   # set the value of a property
  experiment.p.my_property = "some value"   # set the value of a property
  experiment.p.set({'my_property':'value'}) # set the values of some properties
  experiment.set_props({ key: value })      # set the values of some properties

  experiment.save()                         # needed to save/update the changed attributes and properties
  ```



  Samples usually live within experiments/collections:

  - space
    - project
      - experiment / collection
        - sample / object
          - dataset

  The new name for **sample** is **object**. You can use boths names interchangeably:

  - `get_sample()` = `get_object()`
  - `new_sample()` = `new_object()`
  - `get_samples()` = `get_objects()`

  etc.

  ```
  sample = o.new_sample(
      type       = 'YEAST',
      space      = 'MY_SPACE',
      experiment = '/MY_SPACE/MY_PROJECT/EXPERIMENT_1',
      parents    = [parent_sample, '/MY_SPACE/YEA66'],   # you can use either permId, identifier
      children   = [child_sample],                       # or sample object
      props      = {"name": "some name", "description": "something interesting"}
  )
  sample = space.new_sample( type='YEAST' )
  sample.save()

  sample = o.get_sample('/MY_SPACE/MY_SAMPLE_CODE')
  sample = o.get_sample('20170518112808649-52')
  samples= o.get_samples(type='UNKNOWN')    # search for samples, see below


  sample.space
  sample.code
  sample.permId
  sample.identifier
  sample.type  # once the sample type is defined, you cannot modify it


  sample.space = 'MY_OTHER_SPACE'

  sample.experiment    # a sample can belong to one experiment only
  sample.experiment = '/MY_SPACE/MY_PROJECT/MY_EXPERIMENT'

  sample.project
  sample.project = '/MY_SPACE/MY_PROJECT'  # only works if project samples are
  enabled

  sample.tags
  sample.tags = ['guten_tag', 'zahl_tag' ]

  sample.attrs.all()                    # returns all attributes as a dict
  sample.props.all()                    # returns all properties as a dict

  sample.get_attachments()              # deprecated, as attachments are not compatible with ELN-LIMS.
                                        
  sample.download_attachments(<path or cwd>)  # deprecated, see above
  sample.add_attachment('testfile.xls') # deprecated, see above

  sample.delete('deleted for some reason')
  ```



  Creating a single sample takes some time. If you need to create many samples, you might want to create them in one transaction. This will transfer all your sample data at once. The Upside of this is the **gain in speed**. The downside: this is a **all-or-nothing** operation, which means, either all samples will be registered or none (if any error occurs).

  **create many samples in one transaction**

  ```
  trans = o.new_transaction()
  for i in range (0, 100):
      sample = o.new_sample(...)
      trans.add(sample)

  trans.commit()
  ```

  **update many samples in one transaction**

  ```
  trans = o.new_transaction()
  for sample in o.get_samples(count=100):
      sample.prop.some_property = 'different value'
      trans.add(sample)

  trans.commit()
  ```

  **delete many samples in one transaction**

  ```
  trans = o.new_transaction()
  for sample in o.get_samples(count=100):
      sample.mark_to_be_deleted()
      trans.add(sample)

  trans.reason('go what has to go')
  trans.commit()
  ```

  **Note:** You can use the `mark_to_be_deleted()`, `unmark_to_be_deleted()` and `is_marked_to_be_deleted()` methods to set and read the internal flag.



  ```
  sample.get_parents()
  sample.set_parents(['/MY_SPACE/PARENT_SAMPLE_NAME')
  sample.add_parents('/MY_SPACE/PARENT_SAMPLE_NAME')
  sample.del_parents('/MY_SPACE/PARENT_SAMPLE_NAME')

  sample.get_children()
  sample.set_children('/MY_SPACE/CHILD_SAMPLE_NAME')
  sample.add_children('/MY_SPACE/CHILD_SAMPLE_NAME')
  sample.del_children('/MY_SPACE/CHILD_SAMPLE_NAME')



  sample.container    # returns a sample object
  sample.container = '/MY_SPACE/CONTAINER_SAMPLE_NAME'   # watch out, this will change the identifier of the sample to:
                                                         
  sample.container = ''                                  # this will remove the container.





  sample.get_components()
  sample.set_components('/MY_SPACE/COMPONENT_NAME')
  sample.add_components('/MY_SPACE/COMPONENT_NAME')
  sample.del_components('/MY_SPACE/COMPONENT_NAME')
  ```



  ```
  sample.get_tags()
  sample.set_tags('tag1')
  sample.add_tags(['tag2','tag3'])
  sample.del_tags('tag1')
  ```



  **Getting properties**

  ```
  sample.attrs.all()                    # returns all attributes as a dict
  sample.attribute_name                 # return the attribute value

  sample.props == ds.p                  # you can use either .props or .p to access the properties
  sample.p                              # in Jupyter: show all properties in a nice table
  sample.p()                            # get all properties as a dict
  sample.props.all()                    # get all properties as a dict
  sample.p('prop1','prop2')             # get some properties as a dict
  sample.p.get('$name')                 # get the value of a property
  sample.p['property']                  # get the value of a property
  ```

  **Setting properties**

  ```
  sample.experiment = 'first_exp'       # assign sample to an experiment
  sample.project = 'my_project'         # assign sample to a project

  sample.p. + TAB                       # in Jupyter/IPython: show list of available properties
  sample.p.my_property_ + TAB           # in Jupyter/IPython: show datatype or controlled vocabulary
  sample.p['my_property']= "value"      # set the value of a property
  sample.p.set('my_property, 'value')   # set the value of a property
  sample.p.my_property = "some value"   # set the value of a property
  sample.p.set({'my_property':'value'}) # set the values of some properties
  sample.set_props({ key: value })      # set the values of some properties

  sample.save()                         # needed to save/update the attributes and properties
  ```



  The result of a search is always list, even when no items are found. The `.df` attribute returns
  the Pandas dataFrame of the results.

  ```
  samples = o.get_samples(
      space      ='MY_SPACE',
      type       ='YEAST',
      tags       =['*'],                # only sample with existing tags
      start_with = 0,                   # start_with and count
      count      = 10,                  # enable paging
      where = {
          "$SOME.WEIRD-PROP": "hello"   # only receive samples where properties match
      }

      registrationDate = "2020-01-01",  # date format: YYYY-MM-DD
      modificationDate = "<2020-12-31", # use > or < to search for specified date and later / earlier
      attrs=[                           # show these attributes in the dataFrame
          'sample.code',
          'registrator.email',
          'type.generatedCodePrefix'
      ],
      parent_property = 'value',        # search in a parent's property
      child_property  = 'value',        # search in a child's property
      container_property = 'value'      # search in a container's property
      parent = '/MY_SPACE/PARENT_SAMPLE', # sample has this as its parent
      parent = '*',                     # sample has at least one parent
      child  = '/MY_SPACE/CHILD_SAMPLE',
      child  = '*',                     # sample has at least one child
      container = 'MY_SPACE/CONTAINER',
      container = '*'                   # sample lives in a container
      props=['$NAME', 'MATING_TYPE']    # show these properties in the result
  )

  sample = samples[9]                   # get the 10th sample
                                        
  sample = samples['/SPACE/AABC']       # same, fetched by identifier
  for sample in samples:                # iterate over the
     print(sample.code)                 # search results


  samples.df                            # returns a Pandas DataFrame object

  samples = o.get_samples(props="*")    # retrieve all properties of all samples
  ```



  ```
  sample.freeze = True
  sample.freezeForComponents = True
  sample.freezeForChildren = True
  sample.freezeForParents = True
  sample.freezeForDataSets = True
  ```



  Datasets are by all means the most important openBIS entity. The actual files are stored as datasets; all other openBIS entities mainly are necessary to annotate and to structure the data:

  - space
    - project
      - experiment / collection
        - sample / object
          - dataset



  **search for datasets**

  This example does the following

  - search for all datasets of type `SCANS`, retrieve the first 10 entries
  - print out all properties
  - print the list of all files in this dataset
  - download the dataset

  ```
  datasets = sample.get_datasets(type='SCANS', start_with=0, count=10)
  for dataset in datasets:
      print(dataset.props())
      print(dataset.file_list)
      dataset.download()
  dataset = datasets[0]
  ```

  **More dataset functions:**

  ```
  ds = o.get_dataset('20160719143426517-259')
  ds.get_parents()
  ds.get_children()
  ds.sample
  ds.experiment
  ds.physicalData
  ds.status                         # AVAILABLE   LOCKED   ARCHIVED
                                    
                                    
  ds.archive()                      # archives a dataset, i.e. moves it to a slower but cheaper diskspace (tape).
                                    
                                    
                                    
  ds.unarchive()                    # this starts an asynchronous process which gets the dataset from the tape.
                                    

  ds.attrs.all()                    # returns all attributes as a dict
  ds.props.all()                    # returns all properties as a dict

  ds.add_attachment()               # Deprecated. Attachments usually contain meta-data
  ds.get_attachments()              # about the dataSet, not the data itself.
  ds.download_attachments(<path or cwd>)  # Deprecated, as attachments are not compatible with ELN-LIMS.
                                    
  ```



  ```
  o.download_prefix                  # used for download() and symlink() method.
                                     
  ds.get_files(start_folder="/")     # get file list as Pandas dataFrame
  ds.file_list                       # get file list as array
  ds.file_links                      # file list as a dict containing direct https links

  ds.download()                      # simply download all files to data/hostname/permId/
  ds.download(
  	destination = 'my_data',        # download files to folder my_data/
  	create_default_folders = False, # ignore the /original/DEFAULT folders made by openBIS
  	wait_until_finished = False,    # download in background, continue immediately
  	workers = 10                    # 10 downloads parallel (default)
  )
  ds.download_path                   # returns the relative path (destination) of the files after a ds.download()
  ds.is_physical()                   # TRUE if dataset is physically
  ```



  Instead of downloading a dataSet, you can create a symbolic link to a dataSet in the openBIS dataStore. To do that, the openBIS dataStore needs to be mounted first (see mount method above). **Note:** Symbolic links and the mount() feature currently do not work with Windows.

  ```
  o.download_prefix                  # used for download() and symlink() method.
                                     
  ds.symlink()                       # creates a symlink for this dataset: data/hostname/permId
                                     
                                     
  ds.symlink(
     target_dir = 'data/dataset_1/', # default target_dir is: data/hostname/permId
     replace_if_symlink_exists=True
  )
  ds.is_symlink()
  ```



  **Getting properties**

  ```
  ds.attrs.all()                    # returns all attributes as a dict
  ds.attribute_name                 # return the attribute value

  ds.props == ds.p                  # you can use either .props or .p to access the properties
  ds.p                              # in Jupyter: show all properties in a nice table
  ds.p()                            # get all properties as a dict
  ds.props.all()                    # get all properties as a dict
  ds.p('prop1','prop2')             # get some properties as a dict
  ds.p.get('$name')                 # get the value of a property
  ds.p['property']                  # get the value of a property
  ```

  **Setting properties**

  ```
  ds.experiment = 'first_exp'       # assign dataset to an experiment
  ds.sample = 'my_sample'           # assign dataset to a sample

  ds.p. + TAB                       # in Jupyter/IPython: show list of available properties
  ds.p.my_property_ + TAB           # in Jupyter/IPython: show datatype or controlled vocabulary
  ds.p['my_property']= "value"      # set the value of a property
  ds.p.set('my_property, 'value')   # set the value of a property
  ds.p.my_property = "some value"   # set the value of a property
  ds.p.set({'my_property':'value'}) # set the values of some properties
  ds.set_props({ key: value })      # set the values of some properties
  ```



  - The result of a search is always list, even when no items are found
  - The `.df` attribute returns the Pandas dataFrame of the results

  ```
  datasets = o.get_datasets(
      type  ='MY_DATASET_TYPE',
      **{ "SOME.WEIRD:PROP": "value"},  # property name contains a dot or a
                                        
      start_with = 0,                   # start_with and count
      count      = 10,                  # enable paging
      registrationDate = "2020-01-01",  # date format: YYYY-MM-DD
      modificationDate = "<2020-12-31", # use > or < to search for specified date and later / earlier
      parent_property = 'value',        # search in a parent's property
      child_property  = 'value',        # search in a child's property
      container_property = 'value'      # search in a container's property
      parent = '/MY_SPACE/PARENT_DS',   # has this dataset as its parent
      parent = '*',                     # has at least one parent dataset
      child  = '/MY_SPACE/CHILD_DS',
      child  = '*',                     # has at least one child dataset
      container = 'MY_SPACE/CONTAINER_DS',
      container = '*',                  # belongs to a container dataset
      attrs=[                           # show these attributes in the dataFrame
          'sample.code',
          'registrator.email',
          'type.generatedCodePrefix'
      ],
      props=['$NAME', 'MATING_TYPE']    # show these properties in the result
  )
  datasets = o.get_datasets(props="*")  # retrieve all properties of all dataSets
  dataset = datasets[0]                 # get the first dataset in the search result
  for dataset in datasets:              # iterate over the datasets
      ...
  df = datasets.df                      # returns a Pandas dataFrame object of the search results
  ```

  In some cases, you might want to retrieve precisely certain datasets. This can be achieved by
  methods chaining (but be aware, it might not be very performant):

  ```
  datasets = o.get_experiments(project='YEASTS')\
  			 .get_samples(type='FLY')\
  			 .get_datasets(
  					type='ANALYZED_DATA',
  					props=['MY_PROPERTY'],
  					MY_PROPERTY='some analyzed data'
  		 	 )
  ```

  - another example:

  ```
  datasets = o.get_experiment('/MY_NEW_SPACE/MY_PROJECT/MY_EXPERIMENT4')\
             .get_samples(type='UNKNOWN')\
             .get_parents()\
             .get_datasets(type='RAW_DATA')
  ```



  - once a dataSet has been frozen, it cannot be changed by anyone anymore
  - so be careful!

  ```
  ds.freeze = True
  ds.freezeForChildren = True
  ds.freezeForParents = True
  ds.freezeForComponents = True
  ds.freezeForContainers = True
  ds.save()
  ```



  ```
  ds_new = o.new_dataset(
      type       = 'ANALYZED_DATA',
      experiment = '/SPACE/PROJECT/EXP1',
      sample     = '/SPACE/SAMP1',
      files      = ['my_analyzed_data.dat'],
      props      = {'name': 'some good name', 'description': '...' }
  )
  ds_new.save()
  ```



  DataSet containing one zipfile which will be unzipped in openBIS:

  ```python
  ds_new = o.new_dataset(
      type       = 'RAW_DATA',
      sample     = '/SPACE/SAMP1',
      zipfile    = 'my_zipped_folder.zip',
  )
  ds_new.save()
  ```



  - mixed content means: folders and files are provided
  - a relative specified folder (and all its content) will end up in the root, while keeping its structure
    - `../measurements/` --> `/measurements/`
    - `some/folder/somewhere/` --> `/somewhere/`
  - relative files will also end up in the root
    - `my_file.txt` --> `/my_file.txt`
    - `../somwhere/else/my_other_file.txt` --> `/my_other_file.txt`
    - `some/folder/file.txt` --> `/file.txt`
  - useful if DataSet contains files and folders
  - the content of the folder will be zipped (on-the-fly) and uploaded to openBIS
  - openBIS will keep the folder structure intact
  - relative path will be shortened to its basename. For example:

  | local                      | openBIS    |
  | -------------------------- | ---------- |
  | `../../myData/`            | `myData/`  |
  | `some/experiment/results/` | `results/` |

  ```
  ds_new = o.new_dataset(
      type       = 'RAW_DATA',
      sample     = '/SPACE/SAMP1',
      files     = ['../measurements/', 'my_analyis.ipynb', 'results/']
  )
  ds_new.save()
  ```



  A DataSet of kind=CONTAINER contains other DataSets, but no files:

  ```
  ds_new = o.new_dataset(
      type       = 'ANALYZED_DATA',
      experiment = '/SPACE/PROJECT/EXP1',
      sample     = '/SPACE/SAMP1',
      kind       = 'CONTAINER',
      props      = {'name': 'some good name', 'description': '...' }
  )
  ds_new.save()
  ```



  ```
  dataset.get_parents()
  dataset.set_parents(['20170115220259155-412'])
  dataset.add_parents(['20170115220259155-412'])
  dataset.del_parents(['20170115220259155-412'])
  ```



  ```
  dataset.get_children()
  dataset.set_children(['20170115220259155-412'])
  dataset.add_children(['20170115220259155-412'])
  dataset.del_children(['20170115220259155-412'])
  ```



  - A DataSet may belong to other DataSets, which must be of kind=CONTAINER
  - As opposed to Samples, DataSets may belong (contained) to more than one DataSet-container
  - caveat: containers are NOT compatible with ELN-LIMS

  ```
  dataset.get_containers()
  dataset.set_containers(['20170115220259155-412'])
  dataset.add_containers(['20170115220259155-412'])
  dataset.del_containers(['20170115220259155-412'])
  ```

  - a DataSet of kind=CONTAINER may contain other DataSets, to act like a folder (see above)
  - the DataSet-objects inside that DataSet are called components or contained DataSets
  - you may also use the xxx_contained() functions, which are just aliases.
  - caveat: components are NOT compatible with ELN-LIMS

  ```
  dataset.get_components()
  dataset.set_components(['20170115220259155-412'])
  dataset.add_components(['20170115220259155-412'])
  dataset.del_components(['20170115220259155-412'])
  ```



  create semantic annotation for sample type 'UNKNOWN':

  ```

  sa = o.new_semantic_annotation(
  	entityType = 'UNKNOWN',
  	predicateOntologyId = 'po_id',
  	predicateOntologyVersion = 'po_version',
  	predicateAccessionId = 'pa_id',
  	descriptorOntologyId = 'do_id',
  	descriptorOntologyVersion = 'do_version',
  	descriptorAccessionId = 'da_id'
  )
  sa.save()
  ```

  Create semantic annotation for property type (predicate and descriptor values omitted for brevity)

  ```
  sa = o.new_semantic_annotation(propertyType = 'DESCRIPTION', ...)
  sa.save()
  ```

  **Create** semantic annotation for sample property assignment (predicate and descriptor values omitted for brevity)

  ```
  sa = o.new_semantic_annotation(
  	entityType = 'UNKNOWN',
  	propertyType = 'DESCRIPTION',
  	...
  )
  sa.save()
  ```

  **Create** a semantic annotation directly from a sample type. Will also create sample property assignment annotations when propertyType is given:

  ```
  st = o.get_sample_type("ORDER")
  st.new_semantic_annotation(...)
  ```

  **Get all** semantic annotations

  ```
  o.get_semantic_annotations()
  ```

  **Get** semantic annotation by perm id

  ```
  sa = o.get_semantic_annotation("20171015135637955-30")
  ```

  **Update** semantic annotation

  ```
  sa.predicateOntologyId = 'new_po_id'
  sa.descriptorOntologyId = 'new_do_id'
  sa.save()
  ```

  **Delete** semantic annotation

  ```
  sa.delete('reason')
  ```



  ```
  new_tag = o.new_tag(
  	code        = 'my_tag',
  	description = 'some descriptive text'
  )
  new_tag.description = 'some new description'
  new_tag.save()
  o.get_tags()
  o.get_tag('/username/TAG_Name')
  o.get_tag('TAG_Name')

  tag.get_experiments()
  tag.get_samples()
  tag.get_owner()   # returns a person object
  tag.delete('why?')
  ```



  An entity such as Sample (Object), Experiment (Collection), Material or DataSet can be of a specific _entity type_:

  - Sample Type (Object Type)
  - Experiment Type (Collection Type)
  - DataSet Type
  - Material Type

  Every type defines which **Properties** may be defined. Properties act like **Attributes**, but they are type-specific. Properties can contain all sorts of information, such as free text, XML, Hyperlink, Boolean and also **Controlled Vocabulary**. Such a Controlled Vocabulary consists of many **VocabularyTerms**. These terms are used to only allow certain values entered in a Property field.

  So for example, you want to add a property called **Animal** to a Sample and you want to control which terms are entered in this Property field. For this you need to do a couple of steps:

  1. create a new vocabulary _AnimalVocabulary_
  2. add terms to that vocabulary: _Cat, Dog, Mouse_
  3. create a new PropertyType (e.g. _Animal_) of DataType _CONTROLLEDVOCABULARY_ and assign the _AnimalVocabulary_ to it
  4. create a new SampleType (e.g. _Pet_) and _assign_ the created PropertyType to that Sample type.
  5. If you now create a new Sample of type _Pet_ you will be able to add a property _Animal_ to it which only accepts the terms _Cat, Dog_ or _Mouse_.

  **create new Vocabulary with three VocabularyTerms**

  ```
  voc = o.new_vocabulary(
      code = 'BBB',
      description = 'description of vocabulary aaa',
      urlTemplate = 'https://ethz.ch',
      terms = [
          { "code": 'term_code1', "label": "term_label1", "description": "term_description1"},
          { "code": 'term_code2', "label": "term_label2", "description": "term_description2"},
          { "code": 'term_code3', "label": "term_label3", "description": "term_description3"}
      ]
  )
  voc.save()

  voc.vocabulary = 'description of vocabulary BBB'
  voc.chosenFromList = True
  voc.save() # update
  ```

  **create additional VocabularyTerms**

  ```
  term = o.new_term(
  	code='TERM_CODE_XXX',
  	vocabularyCode='BBB',
  	label='here comes a label',
  	description='here might appear a meaningful description'
  )
  term.save()
  ```

  **update VocabularyTerms**

  To change the ordinal of a term, it has to be moved either to the top with the `.move_to_top()` method or after another term using the `.move_after_term('TERM_BEFORE')` method.

  ```
  voc = o.get_vocabulary('STORAGE')
  term = voc.get_terms()['RT']
  term.label = "Room Temperature"
  term.official = True
  term.move_to_top()
  term.move_after_term('-40')
  term.save()
  term.delete()
  ```





  The ELN settings are stored as a **JSON string** in the `$eln_settings` property of the `GENERAL_ELN_SETTINGS` sample. You can show the **Main Menu settings** like this:

  ```python
  import json
  settings_sample = o.get_sample("/ELN_SETTINGS/GENERAL_ELN_SETTINGS")
  settings = json.loads(settings_sample.props["$eln_settings"])
  print(settings["mainMenu"])
  {'showLabNotebook': True,
   'showInventory': True,
   'showStock': True,
   'showObjectBrowser': True,
   'showExports': True,
   'showStorageManager': True,
   'showAdvancedSearch': True,
   'showUnarchivingHelper': True,
   'showTrashcan': False,
   'showVocabularyViewer': True,
   'showUserManager': True,
   'showUserProfile': True,
   'showZenodoExportBuilder': False,
   'showBarcodes': False,
   'showDatasets': True}
  ```

  To modify the **Main Menu settings**, you have to change the settings dictionary, convert it back to json and save the sample:

  ```python
  settings['mainMenu']['showTrashcan'] = False
  settings_sample.props['$eln_settings'] = json.dumps(settings)
  settings_sample.save()
  ```



  The **ELN storages settings** can be found in the samples of project `/ELN_SETTINGS/STORAGES`

  ```python
  o.get_samples(project='/ELN_SETTINGS/STORAGES')
  ```

  To change the settings, just change the sample's properties and save the sample:

  ```python
  sto = o.get_sample('/ELN_SETTINGS/STORAGES/BENCH')
  sto.props()
  {'$name': 'Bench',
   '$storage.row_num': '1',
   '$storage.column_num': '1',
   '$storage.box_num': '9999',
   '$storage.storage_space_warning': '80',
   '$storage.box_space_warning': '80',
   '$storage.storage_validation_level': 'BOX_POSITION',
   '$xmlcomments': None,
   '$annotations_state': None}
   sto.props['$storage.box_space_warning']= '80'
   sto.save()
  ```



  The **ELN templates settings** can be found in the samples of project `/ELN_SETTINGS/TEMPLATES`

  ```python
  o.get_samples(project='/ELN_SETTINGS/TEMPLATES')
  ```

  To change the settings, use the same technique as shown above with the storages settings.



  To change the **Custom Widgets settings**, get the `property_type` and set the `metaData` attribute:

  ```python
  pt = o.get_property_type('YEAST.SOURCE')
  pt.metaData = {'custom_widget': 'Spreadsheet'}
  pt.save()
  ```

  Currently, the value of the `custom_widget` key can be set to either

  - `Spreadsheet` (for tabular, Excel-like data)
  - `Word Processor` (for rich text data)


pkgId: 69dfc1dd56259cb38a24fe7eb834d210462c4f5190590446b59bbe27561e4517
name: python-PyBeatSaver-help
arch: noarch
version: 0.1.16
epoch: 0
release: 1
summary: Development documents and examples for PyBeatSaver
url: https://github.com/Kiyomi-Parents/PyBeatSaver
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyBeatSaver-0.1.16-1.src.rpm
location_href: Packages/python-PyBeatSaver-help-0.1.16-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub license](https://img.shields.io/github/license/Kiyomi-Parents/PyBeatSaver)](https://github.com/Kiyomi-Parents/PyBeatSaver/blob/master/LICENSE)
  [![PyPI version](https://badge.fury.io/py/PyBeatSaver.svg)](https://pypi.org/project/PyBeatSaver)
  [![codecov](https://codecov.io/gh/Kiyomi-Parents/PyBeatSaver/branch/master/graph/badge.svg?token=IUFZTBDVEE)](https://codecov.io/gh/Kiyomi-Parents/PyBeatSaver)
  [![PyPI supported Python versions](https://img.shields.io/pypi/pyversions/pybeatsaver.svg)](https://pypi.org/project/PyBeatSaver)
  [![PyPI downloads](https://img.shields.io/pypi/dm/pybeatsaver?color=blueviolet&logo=pypi)](https://pypi.org/project/PyBeatSaver)

  Beat Saver API wrapper


  * Rate Limit handling
  * Query Caching
  * Everything is ``async``
  * Additional helper methods and async generators
  * Faker data provider

  The faker data mode can be activated with the following ```beatsaver = BeatSaverAPI(test_mode=True)```.
  This will return random data instead of making API requests to Beat Saver.


  ```python
  import asyncio
  from pybeatsaver import BeatSaverAPI, BeatSaver


  async def main():
      async with BeatSaverAPI() as beatsaver:
          beatmap = await beatsaver.beatmap("16d22")
          print(beatmap)


  async def main2():
      beatsaver = BeatSaver()
      await beatsaver.start()

      beatmap = await beatsaver.beatmap("16d22")
      print(beatmap)


  async def main_fake():
      async with BeatSaverAPI(test_mode=True) as beatsaver:
          beatmap = await beatsaver.beatmap("16d22")
          print(beatmap)

  asyncio.run(main())
  asyncio.run(main2())
  asyncio.run(main_fake())
  ```


  ```python
  from faker import Faker
  from pybeatsaver import BeatSaverProvider


  faker = Faker()
  faker.add_provider(BeatSaverProvider)

  beatmap = faker.map_detail()
  print(beatmap)
  ```


pkgId: 612b37972464555325363ec4bafee01949d7eb8746ebde5e061e5151c093e9b4
name: python-PyBerries-help
arch: noarch
version: 0.2.26
epoch: 0
release: 1
summary: Development documents and examples for PyBerries
url: https://gitlab.com/MEKlab/pyberries
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyBerries-0.2.26-1.src.rpm
location_href: Packages/python-PyBerries-help-0.2.26-1.noarch.rpm
checksum_type: sha256
description:
  PyBerries is a Python package that can be used to import, manipulate and plot data from Bacmman measurement tables.

  It relies mainly on Pandas for data handling and Seaborn/Matplotlib for plotting.








    Anaconda will install both Python and Jupyter-lab (used to run Python notebooks) easily. Note however that it requires ~5 Gb free disk space.
    For a lighter installation procedure, see the next section "Command line install".

    - Download Anaconda from the [official website](https://www.anaconda.com/)
    - Run the installer (leave all options as default)
    - Start "Anaconda Navigator"
    - In Anaconda, launch the "Jupyter Lab" module (you might need to click on "Install" first)



    - Open a terminal (macOS/Linux) or Powershell (Windows)
    - Install Python
        - Enter the command `python --version`
        - If an error or a version < 3.9 is shown, download and install Python from the [official website](https://www.python.org/downloads/)
    - After installing, restart your terminal/powershell; the `python --version` command should display a version number > 3.9
    - Install Jupyter Lab
        - In a terminal/powershell, run the command `python -m pip install jupyterlab`
        - After the installation completes, Jupyter Lab can be started using the command `jupyter-lab`



  To install the package, use the following command in a terminal:

  `python -m pip install PyBerries`

  You can also install a specific version number (useful e.g. to make sure you code won't be broken by a future update):

  `python -m pip install PyBerries==0.2.8`

  In a jupyter notebook, use the command:

  `%pip install PyBerries`, or `%pip install PyBerries==0.2.8` for a specific version.



  Try downloading and running the [tutorial notebook](https://gitlab.com/MEKlab/pyberries/-/raw/main/Tutorial/Tutorial.ipynb?inline=false) to get acquainted with data import and plotting in PyBerries.

  For further details, see the [main functionalities](https://gitlab.com/MEKlab/pyberries/-/blob/main/doc/PyBerries_main_functionalities.md) documentation, as well as the [DatasetPool](https://gitlab.com/MEKlab/pyberries/-/blob/main/doc/DatasetPool/DatasetPool.md) documentation.

  For more info and examples on plots, see the [plot_preset documentation](https://gitlab.com/MEKlab/pyberries/-/blob/main/doc/DatasetPool/DatasetPool.plot_preset.md) and the [Seaborn documentation](https://seaborn.pydata.org/index.html)


  For questions and feedback related to this package please send an email to [daniel.thedie@ed.ac.uk](mailto:daniel.thedie@ed.ac.uk)


pkgId: 6bad881448f9684156d0e222558e55130410b8bc75312a768bc09c67750c1e06
name: python-PyCO2SYS-help
arch: noarch
version: 1.8.3.4
epoch: 0
release: 1
summary: Development documents and examples for PyCO2SYS
url: https://pypi.org/project/PyCO2SYS/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyCO2SYS-1.8.3.4-1.src.rpm
location_href: Packages/python-PyCO2SYS-help-1.8.3.4-1.noarch.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/mvdh7/PyCO2SYS/workflows/Tests/badge.svg?branch=main)](https://github.com/mvdh7/PyCO2SYS/actions)
  [![pypi badge](https://img.shields.io/pypi/v/PyCO2SYS.svg?style=popout)](https://pypi.org/project/PyCO2SYS/)
  [![Conda Version](https://img.shields.io/conda/vn/conda-forge/pyco2sys.svg)](https://anaconda.org/conda-forge/pyco2sys)
  [![DOI](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.3744275-informational)](https://doi.org/10.5281/zenodo.3744275)
  [![Docs](https://readthedocs.org/projects/pyco2sys/badge/?version=latest&style=flat)](https://mvdh.xyz/PyCO2SYS/)
  [![Coverage](https://github.com/mvdh7/PyCO2SYS/blob/main/.misc/coverage.svg)](https://github.com/mvdh7/PyCO2SYS/blob/main/.misc/coverage.txt)
  [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  <!-- TOC -->

  - [PyCO2SYS](#pyco2sys)
      - [Introduction](#introduction)
      - [Citation](#citation)
      - [Installation](#installation)
          - [With pip](#with-pip)
          - [With conda/mamba](#with-condamamba)
      - [Documentation](#documentation)
      - [Basic use](#basic-use)
      - [About](#about)
      - [License](#license)

  <!-- /TOC -->



  **PyCO2SYS** is a Python implementation of CO2SYS, based on the [MATLAB v2.0.5](https://github.com/jamesorr/CO2SYS-MATLAB) but also including the updates made for [MATLAB CO2SYS v3](https://github.com/jonathansharp/CO2-System-Extd) as well as some additional related calculations.  PyCO2SYS solves the full marine carbonate system from the values of any two of its parameters.

  Every combination of input parameters has been tested, with differences in the results small enough to be attributable to floating point errors and iterative solver endpoint differences (i.e. negligible).  See the scripts in [validate](https://github.com/mvdh7/PyCO2SYS/tree//validate) to see how and check this for yourself, and their [discussion](https://pyco2sys.readthedocs.io/en/latest/validate/) in the online docs.  **Please [let us know](https://github.com/mvdh7/PyCO2SYS/issues) ASAP if you discover a discrepancy that we have not spotted!**

  Documentation is available online at [PyCO2SYS.readthedocs.io](https://pyco2sys.readthedocs.io/en/latest/).

  There are also some usage examples that you can either download or run live in your web browser (with no Python installation required) at [PyCO2SYS-examples](https://github.com/mvdh7/PyCO2SYS-examples#pyco2sys-examples).



  A paper describing PyCO2SYS is freely available:

  > Humphreys, M. P., Lewis, E. R., Sharp, J. D., and Pierrot, D. (2022).  PyCO2SYS v1.8: marine carbonate system calculations in Python.  *Geoscientific Model Development* 15, 15-43.  [doi:10.5194/gmd-15-15-2022](https://doi.org/10.5194/gmd-15-15-2022).

  Please also specify the full version number that you used.  You can find this in Python with:

  ```python
  import PyCO2SYS as pyco2
  pyco2.hello()
  ```

  As per the instructions in the [the CO2SYS-MATLAB repo](https://github.com/jamesorr/CO2SYS-MATLAB), you should also consider citing the original work by [Lewis and Wallace (1998)](https://pyco2sys.readthedocs.io/en/latest/refs/#l).



  If you manage Python with conda, we recommend that you first install NumPy, pandas and xarray into the environment where PyCO2SYS is to be installed with conda.



  Install from the [Python Package Index](https://pypi.org/project/PyCO2SYS/):

      pip install PyCO2SYS

  Update an existing installation:

      pip install PyCO2SYS --upgrade --no-cache-dir



  Install from the [conda-forge channel](https://anaconda.org/conda-forge/pyco2sys):

      conda install PyCO2SYS -c conda-forge



  Documentation for the current release, based on the `main` branch, is available at [PyCO2SYS.readthedocs.io](https://pyco2sys.readthedocs.io/en/latest/) and at [mvdh.xyz/PyCO2SYS](https://mvdh.xyz/PyCO2SYS/).



  The only function you need is `pyco2.sys`.  To solve the marine carbonate system from two of its parameters (`par1` and `par2`), just use:

  ```python
  import PyCO2SYS as pyco2
  results = pyco2.sys(par1, par2, par1_type, par2_type, **kwargs)
  ```

  The keys to the `results` dict are described in the [documentation](https://pyco2sys.readthedocs.io/en/latest/co2sys_nd/#results).  Arguments should be provided as scalars or NumPy arrays in any mutually broadcastable combination.  A large number of optional `kwargs` can be provided to specify everything beyond the carbonate system parameters — [read the docs!](https://pyco2sys.readthedocs.io/en/latest/co2sys_nd/).

  You can also look at the [examples Notebooks](https://github.com/mvdh7/PyCO2SYS-examples) that you can try out without needing to install anything on your computer.



  PyCO2SYS is maintained by [Dr Matthew Humphreys](https://mvdh.xyz/) at the [NIOZ (Royal Netherlands Institute for Sea Research)](https://www.nioz.nl/en) with the support of the main developers of all previous versions of CO<sub>2</sub>SYS.

  Contributions are welcome - please check the [guidelines](https://github.com/mvdh7/PyCO2SYS/blob/main/CONTRIBUTING.md) before setting to work.



  PyCO2SYS is licensed under the [GNU General Public License version 3 (GPLv3)](https://www.gnu.org/licenses/gpl-3.0.en.html).


pkgId: 6b2245fc7291c8af5c87b9194b222ac2966d9b81a6f4e6a8c9fa690ae9e134d3
name: python-PyEasyUtils-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for PyEasyUtils
url: https://github.com/Spr-Aachen/PyEasyUtils
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyEasyUtils-0.1.2-1.src.rpm
location_href: Packages/python-PyEasyUtils-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  <div align = "center">



  [![Releases](https://img.shields.io/github/v/release/Spr-Aachen/PyEasyUtils?color=green&label=Release&logo=Github&logoColor=white&style=for-the-badge)](https://github.com/Spr-Aachen/PyEasyUtils/releases/latest)&nbsp;

  </div>






  A simple python util library, which is currently used to serve for [QEasyWidgets](https://github.com/Spr-Aachen/QEasyWidgets).






  ```shell
  pip install PyEasyUtils -i https://pypi.org/simple/
  ```


pkgId: 16d153139cf6cea682b7b8a694b6543eb9b907cb65be3b3c8ea7dee0cab0a7bf
name: python-PyFlick-help
arch: noarch
version: 1.1.2
epoch: 0
release: 1
summary: Development documents and examples for PyFlick
url: https://github.com/ZephireNZ/PyFlick
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyFlick-1.1.2-1.src.rpm
location_href: Packages/python-PyFlick-help-1.1.2-1.noarch.rpm
checksum_type: sha256
description:
  ![Build Status](https://github.com/ZephireNZ/PyFlick/actions/workflows/build-and-deploy.yml/badge.svg)
  [![PyPI version](https://badge.fury.io/py/PyFlick.svg)](https://pypi.org/project/PyFlick/)

  A quick and dirty Python API for [Flick Electric](https://flickelectric.co.nz).



  ```python
  from pyflick import FlickAPI
  from pyflick.authentication import SimpleFlickAuth
  from aiohttp import ClientSession

  def async get_flick_pricing():
      async with ClientSession() as session:
          auth = SimpleFlickAuth("USERNAME", "PASSWORD", session)

          api = FlickAPI(auth)

          return await api.getPricing()
  ```

  The `SimpleFlickAuth` client can also accept custom client ID and secret (this can be found by sniffing the client).

  API will return a `FlickPrice` object for accessing the price information.

  You can also get the raw data via `FlickPrice.raw`.

  This will return a price object that looks a little like this:

  ```json
  {
    "kind": "mobile_provider_price",
    "customer_state": "active",
    "needle": {
      "price": "11.163",
      "status": "urn:flick:market:price:no_contract",
      "unit_code": "cents",
      "per": "kwh",
      "start_at": "2020-04-19T02:30:00Z",
      "end_at": "2020-04-19T02:59:59Z",
      "now": "2020-04-19T02:34:38.410Z",
      "type": "rated",
      "charge_methods": [
        "kwh"
      ],
      "components": [
        {
          "kind": "component",
          "charge_method": "kwh",
          "charge_setter": "retailer",
          "value": "4.26",
          "quantity": "1.0",
          "unit_code": "cents",
          "per": "kwh",
          "flow_direction": "import",
          "metadata": {
            "content_code": "UN",
            "channel_number": 1,
            "meter_serial_number": "RD1111111",
            "hours_of_availability": 24
          },
          "_links": {}
        },
        ...
      ]
    }
  }
  ```

rpm_license:
  The MIT License (MIT)  Copyright (c) 2013 Drian Naude  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: f7ee90842bffaa9ac42d3175e87ef2f0d39e787cf6b8a25cfacfe8b463c06c13
name: python-PyFlyt-help
arch: noarch
version: 0.28.0
epoch: 0
release: 1
summary: Development documents and examples for PyFlyt
url: https://pypi.org/project/PyFlyt/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyFlyt-0.28.0-1.src.rpm
location_href: Packages/python-PyFlyt-help-0.28.0-1.noarch.rpm
checksum_type: sha256
description:
  Comes with Gymnasium and PettingZoo environments built in!

  <p align="center">
      <img src="https://github.com/jjshoots/PyFlyt/blob/master/readme_assets/pyflyt_cover_photo.png?raw=true" width="600"/>
  </p>



  This is a library for testing reinforcement learning algorithms on UAVs.
  This repo is still under development.
  We are also actively looking for users and developers, if this sounds like you, don't hesitate to get in touch!



  ```sh
  pip3 install wheel numpy
  pip3 install pyflyt
  ```

  > `numpy` and `wheel` must be installed prior to `pyflyt` such that `pybullet` is built with `numpy` support.



  Usage is similar to any other Gymnasium and PettingZoo environment:



  ```python
  import gymnasium
  import PyFlyt.gym_envs # noqa

  env = gymnasium.make("PyFlyt/QuadX-Hover-v2", render_mode="human")
  obs = env.reset()

  termination = False
  truncation = False

  while not termination or truncation:
      observation, reward, termination, truncation, info = env.step(env.action_space.sample())
  ```

  View the official documentation for gymnasium environments [here](https://jjshoots.github.io/PyFlyt/documentation/gym_envs.html).



  ```python
  from PyFlyt.pz_envs import MAFixedwingDogfightEnv

  env = MAFixedwingDogfightEnv(render_mode="human")
  observations, infos = env.reset()

  while env.agents:
      
      actions = {agent: env.action_space(agent).sample() for agent in env.agents}

      observations, rewards, terminations, truncations, infos = env.step(actions)
  env.close()
  ```

  View the official documentation for pettingzoo environments [here](https://jjshoots.github.io/PyFlyt/documentation/pz_envs.html).



  If you use our work in your research and would like to cite it, please use the following bibtex entry:

  ```
  @article{tai2023pyflyt,
    title={PyFlyt--UAV Simulation Environments for Reinforcement Learning Research},
    author={Tai, Jun Jet and Wong, Jim and Innocente, Mauro and Horri, Nadjim and Brusey, James and Phang, Swee King},
    journal={arXiv preprint arXiv:2304.01305},
    year={2023}
  }
  ```



  <p align="center">
      <img src="https://github.com/jjshoots/PyFlyt/blob/master/readme_assets/fixedwing_waypoint.gif?raw=true" height="250px"/>
      <img src="https://github.com/jjshoots/PyFlyt/blob/master/readme_assets/fixedwing_dogfight.gif?raw=true" height="250px"/>
  </p>
  <p align="center">
      <img src="https://github.com/jjshoots/PyFlyt/blob/master/readme_assets/quadx_pole_waypoint.gif?raw=true" height="200px"/>
      <img src="https://github.com/jjshoots/PyFlyt/blob/master/readme_assets/quadx_waypoint.gif?raw=true" height="200px"/>
      <img src="https://github.com/jjshoots/PyFlyt/blob/master/readme_assets/quadx_ball_in_cup.gif?raw=true" height="200px"/>
  </p>

rpm_license:
  MIT License  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: 74c29b46ad4cbe22201f39abfc455428881a087529eb2eff2fe444fbef070ad5
name: python-PyIndexRepo-help
arch: noarch
version: 0.1.6
epoch: 0
release: 1
summary: Development documents and examples for PyIndexRepo
url: https://pypi.org/project/PyIndexRepo/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyIndexRepo-0.1.6-1.src.rpm
location_href: Packages/python-PyIndexRepo-help-0.1.6-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://img.shields.io/pypi/v/PyIndexRepo)](https://pypi.org/project/PyIndexRepo/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/PyIndexRepo)](https://pypi.org/project/PyIndexRepo/)
  ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/Stuermer/PyIndexRepo/tests.yaml?label=pytest)
  [![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/Stuermer/PyIndexRepo/docs.yaml?label=mkdocs&link=https%3A%2F%2Fstuermer.github.io%2FPyIndexRepo%2F)](https://stuermer.github.io/PyIndexRepo/)
  [![Coverage Status](https://coveralls.io/repos/github/Stuermer/PyIndexRepo/badge.svg?branch=master)](https://coveralls.io/github/Stuermer/PyIndexRepo?branch=master)




  This package gives access to the refractive index data from [RefractiveIndex.info]().

  The focus of this package is to provide a convenient interface to the data, and be
  efficient in the calculation of (temperature-dependent) refractive indices.





  ```python
  from pyindexrepo import RefractiveIndexLibrary

  db = RefractiveIndexLibrary(auto_upgrade=True)
  bk7 = db.search_material_by_page_name('N-BK7')[0]  # returns a list of different BK7 glasses
  print(bk7.get_n(0.5875618))
  ```

  When executed for the first time, the database from the
  RefractiveIndex [Github Repo](https://github.com/polyanskiy/refractiveindex.info-database) will be downloaded and
  converted to a python object. This process takes a few minutes. Consecutive calls will load the database object
  from a local file (almost instantaneously).

  Auto-upgrade of the library is supported, but switched off by default.

  There are two main classes that allow interacting with the data: the RefractiveIndexLibrary class
  and the Material class.



  When temperature data is available, the refractive index of a material can be queried at any temperature
  within the valid temperature range:

  ```python
  import numpy as np
  from pyindexrepo import RefractiveIndexLibrary

  db = RefractiveIndexLibrary(auto_upgrade=True)
  bk7 = db.search_material_by_page_name('N-BK7')[0]  # returns a list of different BK7 glasses
  wl = np.linspace(0.4, 0.7, 10000)
  print(bk7.get_n_at_temperature(wl, temperature=30))
  ```

  ```
  [1.53088657 1.53088257 1.53087857 ... 1.51309187 1.51309107 1.51309027]
  ```



  ```bash
  pip install pyindexrepo
  ```


pkgId: 457a3d4bea61fbf25db8455da0de58959062d7fb5d5160fa2455997362a3bd83
name: python-PyJHora-help
arch: noarch
version: 4.0.3
epoch: 0
release: 1
summary: Development documents and examples for PyJHora
url: https://pypi.org/project/PyJHora/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyJHora-4.0.3-1.src.rpm
location_href: Packages/python-PyJHora-help-4.0.3-1.noarch.rpm
checksum_type: sha256
description:
  Python package containing almost all the features described in the book
  `Vedic Astrology - An Integrated Approach - by PVR Narasimha Rao`
  ![Vedic Astrology - An Integrated Approach by PVR Narasimha Rao](../jhora/images/pvr_ebook.jpg)
  and
  the free astrology software `Jagannatha Hora V8.0 software` by the same author.
   ![Jagannatha Hora V8.0 software](../jhora/images/jhora_pvr.jpg)
  This python library was inspired by his book and software. Almost all the results have been verified against the examples and exercises provided in the book. Also the features that are outside of his book but in his JHora software were collected from various internet sources and have been verified closest to results obtained using JHora software.
  There is a test module (`jhora.tests.pvr_tests`) containing about 5600 tests that can be run to verify the same. Please note the tests assume `const._DEFAULT_AYANAMSA_MODE='LAHIRI'`.
  Having said that, if you find this package useful, all the credits go to Shri. P.V.R Narasimha Rao for such a wonderful book and the software and to the other internet sources.

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


pkgId: e8b0ac1f39d3004ae87c9d67077b4f5f936ed31ba9e8e79c4c98408ab9e9ac67
name: python-PyNormaliz-inequalities-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for PyNormaliz-inequalities
url: https://github.com/DominikPeters/PyNormaliz_inequalities
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyNormaliz-inequalities-0.1.2-1.src.rpm
location_href: Packages/python-PyNormaliz-inequalities-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  [Normaliz](https://github.com/Normaliz/Normaliz) is a tool for various computations in discrete convex geometry. In particular it supports computations in polytopes and polyhedra specified by a system of linear inequalities.
  For example, it allows to compute the Hilbert or Ehrhart series of a polytope or polyhedron, and thereby count the number of integer points in it.

  It is possible to interact with Normaliz using the Python package [PyNormaliz](https://github.com/Normaliz/PyNormaliz), but the interface requires users to specify inequalities in a vector format.
  This package provides a more convenient interface for specifying inequalities in a natural format, and includes utility functions for interacting with PyNormaliz.



  Normaliz and PyNormaliz must be installed on your system to use this package. You can install these packages using the following commands:

  ```sh
  git clone https://github.com/Normaliz/Normaliz.git
  cd Normaliz
  ./install_normaliz.sh
  ./install_pynormaliz.sh
  ```

  To install this package, use pip:

  ```sh
  pip install PyNormaliz_inequalities
  ```



  The main point of the package is to allow users to specify inequalities in a natural format.
  The main components are `Variable`s that can be combined into `Expression`s and `Inequality`s, which can be collected into an `InequalitySystem`, which can then be passed to PyNormaliz.



  Let's count the number of integer pairs `(a,b)` with `a + b = n` that satisfy the inequalities `a >= 0`, `b >= 0`, and `a + b >= 1`, as a function of `n`.

  ```python
  from PyNormaliz_inequalities import Variable, InequalitySystem, evaluate_quasipolynomial

  a = Variable()
  b = Variable()

  inequalities = InequalitySystem()
  inequalities.add_inequality(a >= 0)
  inequalities.add_inequality(b >= 0)
  inequalities.add_inequality(a + b >= 1)

  quasipolynomial = inequalities.construct_homogeneous_cone().HilbertQuasiPolynomial()
  print([evaluate_quasipolynomial(quasipolynomial, n) for n in range(10)])
  ```



  The `PyNormaliz_inequalities` package provides a convenient interface to PyNormaliz, allowing users to specify inequalities in a natural format. It supports creating variables, expressions, and inequalities, and converting them to vector representations suitable for PyNormaliz. The package also includes functionality to construct homogeneous cones and compute Hilbert quasi-polynomials.

  The main components of the package are:

  - `Variable`: Represents a variable in an inequality.
  - `Expression`: Represents a linear expression involving variables.
  - `Inequality`: Represents an inequality involving expressions.
  - `InequalitySystem`: Manages a system of inequalities and provides methods to interact with PyNormaliz.

  The package also includes utility functions for converting inequalities to vector representations and evaluating quasi-polynomials.


pkgId: 1f641e48184362b21e42ccc7c67491dbca6edf2842a844f5461744b0e07dae94
name: python-PyQUDA-Utils-help
arch: noarch
version: 0.10.1.dev1
epoch: 0
release: 1
summary: Development documents and examples for PyQUDA-Utils
url: https://github.com/CLQCD/PyQUDA
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyQUDA-Utils-0.10.1.dev1-1.src.rpm
location_href: Packages/python-PyQUDA-Utils-help-0.10.1.dev1-1.noarch.rpm
checksum_type: sha256
description:
  Python wrapper for [QUDA](https://github.com/lattice/quda) written in Cython.

  This project aims to benefit from the optimized linear algebra library [CuPy](https://cupy.dev/) in Python based on CUDA. CuPy and QUDA will allow us to perform most lattice QCD research operations with high performance. [PyTorch](https://pytorch.org/) is an alternative option.

  This project is based on the latest QUDA `develop` branch. PyQUDA should be compatible with any commit of QUDA after https://github.com/lattice/quda/pull/1489, but leave some features disabled.



  - Multi-GPU supported
    - with [MPI for Python](https://mpi4py.readthedocs.io/en/stable/) package
  - File I/O
    - Read gauge and propagator in Chroma format (with checksum)
    - Read gauge and propagator in MILC format (with checksum)
    - Read/write gauge and propagator in KYU format
    - Read/write gauge and propagator in XQCD format
    - Read/write gauge and propagator in NPY format (numpy)
  - Quark propagator
    - Isotropic/anisotropic Wilson fermion action with multigrid support
    - Isotropic/anisotropic Clover fermion action with multigrid support
    - Isotropic HISQ fermion action
  - HMC
    - Isotropic gauge action
    - 1-flavor isotropic clover fermion action
    - 2-flavor isotropic clover fermion action
    - N-flavor isotropic HISQ fermion action
  - Gauge fixing
    - Rotation field with over-relaxation method (waiting for QUDA merge)
  - Gauge smearing
    - 3D/4D APE smearing
    - 3D/4D stout smearing
    - 3D/4D HYP smearing
  - Fermion smearing
    - Gaussian smearing
  - Gradient flow
    - Wilson flow
    - Symanzik flow





  Assuming the QUDA installation path is `/path/to/quda/build/usqcd`

  ```bash
  export QUDA_PATH=/path/to/quda/build/usqcd
  python3 -m pip install pyquda pyquda-utils
  ```



  Refer to https://github.com/CLQCD/PyQUDA/wiki/Installation for detailed instructions to install PyQUDA from the source.



  Refer to https://github.com/CLQCD/PyQUDA/wiki/Benchmark for detailed instructions to run the PyQUDA benchmark.



  https://github.com/CLQCD/PyQUDA/wiki/Documentation



  We recommend building PyQUDA using in-place mode instead of installing PyQUDA for development.

  ```bash
  git clone --recursive https://github.com/CLQCD/PyQUDA.git
  cd PyQUDA
  ln -s pyquda_core/pyquda pyquda
  cd pyquda_core
  export QUDA_PATH=/path/to/quda/build/usqcd
  python3 setup.py build_ext --inplace
  ```

  Now you can modify Python files in the project and immediately get the new result by running scripts. Adding the root directory to `sys.path` is needed if you are running scripts from other directories.



  Function definitions (mainly in `quda.in.pxd` and `pyquda.in.pyx`) and most docstrings (mainly in `pyquda.pyi` and `enum_quda.in.py`) should be manually updated as they cannot be autogenerated now. This also means PyQUDA should work well with future versions if the API remains unchanged.

rpm_license:
  MIT License  Copyright (c) 2022-2024 PyQUDA Developers  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: f1fb390e6280739dc568c43721fbb0b9b8a2d47761d776dc92754ec97cfb2821
name: python-PyQt3D-Qt5
arch: noarch
version: 5.15.16
epoch: 0
release: 1
summary: The subset of a Qt installation needed by PyQt3D.
url: https://www.riverbankcomputing.com/software/pyqt/
rpm_license: LGPL v3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyQt3D-Qt5-5.15.16-1.src.rpm
location_href: Packages/python-PyQt3D-Qt5-5.15.16-1.noarch.rpm
checksum_type: sha256
description:
  This package contains the subset of a Qt installation that is required by
  PyQt3D.  It would normally be installed automatically by pip when
  you install PyQt3D.

  This package is licensed under the terms of the LGPL v3.


pkgId: ac01c61cf6f6abb8692c1277705152c1146404daebe202e048648d4d8b18c2d9
name: python-PyQt5-Qt5
arch: noarch
version: 5.15.16
epoch: 0
release: 1
summary: The subset of a Qt installation needed by PyQt5.
url: https://www.riverbankcomputing.com/software/pyqt/
rpm_license: LGPL v3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyQt5-Qt5-5.15.16-1.src.rpm
location_href: Packages/python-PyQt5-Qt5-5.15.16-1.noarch.rpm
checksum_type: sha256
description:
  This package contains the subset of a Qt installation that is required by
  PyQt5.  It would normally be installed automatically by pip when
  you install PyQt5.

  This package is licensed under the terms of the LGPL v3.


pkgId: 32dc91b878e608f39bb5c0f94fbe828333a4b779de0675032b332d84764a303b
name: python-PyQtChart-Qt5
arch: noarch
version: 5.15.16
epoch: 0
release: 1
summary: The subset of a Qt installation needed by PyQtChart.
url: https://www.riverbankcomputing.com/software/pyqt/
rpm_license: GPL v3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyQtChart-Qt5-5.15.16-1.src.rpm
location_href: Packages/python-PyQtChart-Qt5-5.15.16-1.noarch.rpm
checksum_type: sha256
description:
  This package contains the subset of a Qt installation that is required by
  PyQtChart.  It would normally be installed automatically by pip when
  you install PyQtChart.

  This package is licensed under the terms of the GPL v3.


pkgId: 4b09990c5d8cee0b5c9aed2dbdaf3e30b31004248c7897ae3c1eb7c0ec82a189
name: python-PyQtDataVisualization-Qt5
arch: noarch
version: 5.15.16
epoch: 0
release: 1
summary: The subset of a Qt installation needed by PyQtDataVisualization.
url: https://www.riverbankcomputing.com/software/pyqt/
rpm_license: GPL v3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyQtDataVisualization-Qt5-5.15.16-1.src.rpm
location_href: Packages/python-PyQtDataVisualization-Qt5-5.15.16-1.noarch.rpm
checksum_type: sha256
description:
  This package contains the subset of a Qt installation that is required by
  PyQtDataVisualization.  It would normally be installed automatically by pip when
  you install PyQtDataVisualization.

  This package is licensed under the terms of the GPL v3.


pkgId: 03835c7b89156772b10bd63a13d2748f51b764f70bc3aec8376a226634fa5feb
name: python-PyQtNetworkAuth-Qt5
arch: noarch
version: 5.15.16
epoch: 0
release: 1
summary: The subset of a Qt installation needed by PyQtNetworkAuth.
url: https://www.riverbankcomputing.com/software/pyqt/
rpm_license: GPL v3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyQtNetworkAuth-Qt5-5.15.16-1.src.rpm
location_href: Packages/python-PyQtNetworkAuth-Qt5-5.15.16-1.noarch.rpm
checksum_type: sha256
description:
  This package contains the subset of a Qt installation that is required by
  PyQtNetworkAuth.  It would normally be installed automatically by pip when
  you install PyQtNetworkAuth.

  This package is licensed under the terms of the GPL v3.


pkgId: a9e5de51c010cf5d82b32c0ca43055ce8490eec98f767bc4bf315ff34f37eb6d
name: python-PyQtPurchasing-Qt5
arch: noarch
version: 5.15.16
epoch: 0
release: 1
summary: The subset of a Qt installation needed by PyQtPurchasing.
url: https://www.riverbankcomputing.com/software/pyqt/
rpm_license: LGPL v3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyQtPurchasing-Qt5-5.15.16-1.src.rpm
location_href: Packages/python-PyQtPurchasing-Qt5-5.15.16-1.noarch.rpm
checksum_type: sha256
description:
  This package contains the subset of a Qt installation that is required by
  PyQtPurchasing.  It would normally be installed automatically by pip when
  you install PyQtPurchasing.

  This package is licensed under the terms of the LGPL v3.


pkgId: ad9187a92a3080c2da0e96e006db80b7f459bde6429b7048d343c59fe09c990f
name: python-PyQtWebEngine-Qt5
arch: noarch
version: 5.15.16
epoch: 0
release: 1
summary: The subset of a Qt installation needed by PyQtWebEngine.
url: https://www.riverbankcomputing.com/software/pyqt/
rpm_license: LGPL v3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyQtWebEngine-Qt5-5.15.16-1.src.rpm
location_href: Packages/python-PyQtWebEngine-Qt5-5.15.16-1.noarch.rpm
checksum_type: sha256
description:
  This package contains the subset of a Qt installation that is required by
  PyQtWebEngine.  It would normally be installed automatically by pip when
  you install PyQtWebEngine.

  This package is licensed under the terms of the LGPL v3.


pkgId: 83ff8b14e976d9efccc11ad6faeeb9d84e3a304fa5b6a8b743829b5e27941c23
name: python-PySDM-examples-help
arch: noarch
version: 2.90
epoch: 0
release: 1
summary: Development documents and examples for PySDM-examples
url: https://github.com/open-atmos/PySDM
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PySDM-examples-2.90-1.src.rpm
location_href: Packages/python-PySDM-examples-help-2.90-1.noarch.rpm
checksum_type: sha256
description:
  <img align="left" src="https://raw.githubusercontent.com/open-atmos/PySDM/main/docs/logos/pysdm_logo.svg" width=150 height=219 alt="pysdm logo" style="padding-right:1em">

  PySDM examples are engineered as Jupyter Python notebooks supported by auxiliary Python commons
    that constitute a separate <mark>PySDM-examples</mark> Python package which is also
    <a href="https://pypi.org/p/PySDM-examples">available at PyPI</a>.
  The examples have additional dependencies listed in
    <a href="https://github.com/open-atmos/PySDM/blob/main/examples/setup.py">PySDM-examples package setup.py file</a>.
  Running the example Jupyter notebooks requires the <mark>PySDM-examples</mark> package to be pip-installed.
  For installation instructions see [project docs homepage](https://open-atmos.github.io/PySDM).
  Note that the Jupyter notebooks themselves are not included in the package wheels, but are included
    in the source .tar.gz file on PyPI, and are conveninently browsable on GitHub.
  All notebooks feature header cells with badges enabling single-click execution on
    <a href="https://colab.research.google.com/">Google Colab</a> and on
    <a href="https://mybinder.org/">mybinder.org</a>.
  The examples package is also used in the PySDM test suite.



  The examples are named referring to the journal paper they aim to reproduce simulations from
  (or sometimes just where the inspiration originated from).
  The list below groups all examples by the dimensionality and type of the employed modelling framework
  ("environment" in PySDM nomenclature, which can be: <mark>box</mark>, <mark>parcel</mark>,
  <mark>single-column</mark>, <mark>2D prescribed flow</mark>), and by the set of physical processes simulated
  (<mark>condensation</mark>, collisional <mark>coagulation</mark> and <mark>breakup</mark>,
  <mark>drop freezing</mark>, <mark>isotopic fractionation</mark>, <mark>aqueous chemistry</mark>,
  <mark>seeding</mark>, ...).



  The 2D prescribed-flow framework used here can be traced back to the work of
    <a href="https://doi.org/10.1007/978-1-935704-36-2_1">Kessler 1969 (section 3C)</a>.
    The setup employed in PySDM-examples, which mimics a stratiform cloud deck and features periodic horizontal boundary condition
      and vanishing flow at vertical boundaries, was introduced in <a href="https://doi.org/10.1175/JAS3980">Morrison and Grabowski (2007)</a>
      and later adopted for particle-based simulations in <a href="https://doi.org/10.5194/gmd-8-1677-2015">Arabas et al. (2015)</a>.
    It uses a non-devergent single-eddy flow field resulting in an updraft-downdraft pair in the domain.
    The flow field advects two scalar fields in an Eulerian way: water vapour mixing ratio
      and dry-air potential temperature.
    In PySDM-examples, the Eulerian advection is handled using the <a href="https://doi.org/10.21105/joss.03896">PyMPDATA</a> Numba-based
      implementation of the <a href="https://doi.org/10.1002/fld.1071">MPDATA numerical scheme of Smolarkiewicz (e.g., 2006)</a>.
    An animation depicting PySDM simulation capturing <mark>aerosol collisional processing</mark> by warm rain is shown below:

  ![animation](https://github.com/open-atmos/PySDM/wiki/files/kinematic_2D_example.gif)

  Example notebooks:
  - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Arabas_et_al_2015.html">Arabas_et_al_2015</a>
    - in-notebook GUI for setting up, running and interactively visualising the 2D kinematic simulations (with an option to export raw data to <mark>VTK</mark> and <mark>netCDF</mark> files, as well as to save plots to SVG or PDF):
    - "hello world" notebook depicting how to automate using Python the process of loading data and creating animations in <mark>Paraview</mark>
  - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Arabas_et_al_2023.html">Arabas_et_al_2023</a>: adaptation of the 2D kinematic setup for studying <mark>glaciation</mark> of the cloud deck by <mark>immersion freezing</mark>



  The single-column PySDM environment is a reimplementation of the <mark>Met Office KiD framework</mark>
    introduced in <a href="https://doi.org/10.1002/qj.1913">Shipway & Hill 2012</a>.
  The framework features a single Eulerian-transported field of water vapour mixing ratio
    (vertical profile of potential temperature is fixed).
  As in the 2D kinematic framework above, the Eulerian advection is handled by
    <a href="https://open-atmos.github.io/PyMPDATA/">PyMPDATA</a>.

  Example notebooks:
  - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Shipway_and_Hill_2012.html">Shipway_and_Hill_2012</a>: reproducing figures from the <a href="https://doi.org/10.1002/qj.1913">Shipway & Hill 2012</a> paper;
  - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/deJong_Mackay_et_al_2023.html">deJong_Mackay_et_al_2023</a>: reproducing figures from the <a href="https://doi.org/10.5194/gmd-16-4193-2023">de Jong et al. 2023</a> paper where the single-column
     framework was used to exemplify operation of the <mark>Monte-Carlo collisional breakup scheme</mark> in PySDM (scheme introduced in that paper).



  This framework uses a parcel model with removal of precipitation for analysis,
  iterative equilibration, the isotopic composition of the water vapour and
  rain water in a column of air (no Eulerian transport, only iterative passage of a parcel through the column).

  <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Rozanski_and_Sonntag_1982.html">Rozanski_and_Sonntag_1982</a>: bulk microphysics example (i.e. single super droplet) with
  deuterium and heavy-oxygen <mark>water isotopologues</mark> featured.



  The parcel framework implemented in PySDM uses a hydrostatic profile and adiabatic mass and energy conservation
    to drive evolution of thermodynamic state and microphysical properties of particles.

  Example notebooks include:
  - condensation only
    - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Arabas_and_Shima_2017.html">Arabas_and_Shima_2017</a>: monodisperse particle spectrum, activation/deactivation cycle
    - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Yang_et_al_2018.html">Yang_et_al_2018</a>: polydisperse particle spectrum, activation/deactivation cycles
    - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Abdul_Razzak_Ghan_2000.html">Abdul_Razzak_Ghan_2000</a>: polydisperse activation, comparison against <mark>GCM parameterisation</mark>
    - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Pyrcel.html">Pyrcel</a>: polydisperse activation, mimicking example test case from <mark>Pyrcel</mark> documentation
    - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Lowe_et_al_2019.html">Lowe_et_al_2019</a>: externally mixed polydisperse size spectrum with <mark>surface-active organics</mark> case
    - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Grabowski_and_Pawlowska_2023.html">Grabowski_and_Pawlowska_2023</a>: polydisperse activation, focus on <mark>ripening</mark>
    - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Jensen_and_Nugent_2017.html">Jensen_and_Nugent_2017</a>: polydisperse activation featuring <mark>giant CCN</mark>
  - condensation and aqueous-chemistry
    - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Kreidenweis_et_al_2003.html">Kreidenweis_et_al_2003</a>: <mark>Hoppel gap</mark> simulation setup (i.e. depiction of evolution of aerosol mass spectrum from a monomodal to bimodal due to aqueous‐phase SO2 oxidation)
    - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Jaruga_and_Pawlowska_2018.html">Jaruga_and_Pawlowska_2018</a>: exploration of numerical convergence using the above Hoppel-gap simulation setup

  The parcel environment is also featured in the <a href="https://open-atmos.github.io/PySDM/PySDM.html#tutorials">PySDM tutorials</a>.



  The box environment is void of any spatial or thermodynamic context, it constitutes the most basic framework.

  Example notebooks include:

  - coalescence only:
    - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Shima_et_al_2009.html">Shima_et_al_2009</a>: using <mark>Golovin additive kernel</mark> for comparison against analytic solution, featuring interactive in-notebook interface for selecting simulation parameters
    - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Berry_1967.html">Berry_1967</a>: examples using geometric, hydrodynamic and electric-field collision kernels
  - coalescence and breakup:
    - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Bieli_et_al_2022.html">Bieli_et_al_2022</a>: evolution of moments under collisional growth and breakage
    - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/deJong_Mackay_et_al_2023.html">deJong_Mackay_et_al_2023</a>: validation of the breakup scheme against analytical solutions from <a href="https://doi.org/10.1175/1520-0469(1982)039%3C1317:ASMOPC%3E2.0.CO;2">Srivastava 1982</a>
  - immersion freezing only:
    - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Alpert_and_Knopf_2016.html">Alpert_and_Knopf_2016</a>: stochastic immersion freezing with monodisperse vs. lognormal immersed surface areas
    - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Arabas_et_al_2023.html">Arabas_et_al_2023</a>: comparison of time-dependent and singular immersion freezing schemes

  The box environment is also featured in the <a href="https://open-atmos.github.io/PySDM/PySDM.html#tutorials">PySDM tutorials</a>.


  - <mark>equilibrium isotopic fractionation</mark> formulae:
    - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Lamb_et_al_2017.html">Lamb_et_al_2017</a>
    - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Bolot_et_al_2013.html">Bolot_et_al_2013</a>
    - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Merlivat_and_Nief_1967.html">Merlivat_and_Nief_1967</a>
    - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Van_Hook_1968.html">Van_Hook_1968</a>
    - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Graf_et_al_2019.html">Graf_et_al_2019</a>
  - <mark>Rayleigh fractionation</mark>:
    - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Pierchala_et_al_2022.html">Pierchala_et_al_2022</a>: reproducing model plots for a <mark>triple-isotope</mark> lab study, including <mark>kinetic fractionation</mark>
  - isotopic relaxation timescale:
    - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Miyake_et_al_1968.html">Miyake_et_al_1968</a>: incl. comparison of different <mark>ventilation</mark> parameterisations
    - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Bolin_1958.html">Bolin_1958</a>
  - below-cloud <mark>kinetic fractionation</mark>:
    - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Gedzelman_and_Arnold_1994.html">Gedzelman_and_Arnold_1994</a>


pkgId: 901d4202ee383bc14f5b5a96a76d7636f7d20f3ebf502e962a91b3c731eded98
name: python-PySDM-help
arch: noarch
version: 2.90
epoch: 0
release: 1
summary: Development documents and examples for PySDM
url: https://github.com/open-atmos/PySDM
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PySDM-2.90-1.src.rpm
location_href: Packages/python-PySDM-help-2.90-1.noarch.rpm
checksum_type: sha256
description:
  [![Python 3](https://img.shields.io/static/v1?label=Python&logo=Python&color=3776AB&message=3)](https://www.python.org/)
  [![LLVM](https://img.shields.io/static/v1?label=LLVM&logo=LLVM&color=gold&message=Numba)](https://numba.pydata.org)
  [![CUDA](https://img.shields.io/static/v1?label=CUDA&logo=nVidia&color=87ce3e&message=ThrustRTC)](https://pypi.org/project/ThrustRTC/)
  [![Linux OK](https://img.shields.io/static/v1?label=Linux&logo=Linux&color=yellow&message=%E2%9C%93)](https://en.wikipedia.org/wiki/Linux)
  [![macOS OK](https://img.shields.io/static/v1?label=macOS&logo=Apple&color=silver&message=%E2%9C%93)](https://en.wikipedia.org/wiki/macOS)
  [![Windows OK](https://img.shields.io/static/v1?label=Windows&logo=Windows&color=white&message=%E2%9C%93)](https://en.wikipedia.org/wiki/Windows)
  [![Jupyter](https://img.shields.io/static/v1?label=Jupyter&logo=Jupyter&color=f37626&message=%E2%9C%93)](https://jupyter.org/)
  [![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://github.com/open-atmos/PySDM/graphs/commit-activity)
  [![OpenHub](https://www.openhub.net/p/atmos-cloud-sim-uj-PySDM/widgets/project_thin_badge?format=gif)](https://www.openhub.net/p/atmos-cloud-sim-uj-PySDM)
  [![status](https://joss.theoj.org/papers/62cad07440b941f73f57d187df1aa6e9/status.svg)](https://joss.theoj.org/papers/62cad07440b941f73f57d187df1aa6e9)
  [![DOI](https://zenodo.org/badge/199064632.svg)](https://zenodo.org/badge/latestdoi/199064632)
  [![EU Funding](https://img.shields.io/static/v1?label=EU%20Funding%20by&color=103069&message=FNP&logoWidth=25&logo=image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAC4AAAAeCAYAAABTwyyaAAAEzklEQVRYw9WYS2yUVRiGn3P5ZzozpZ3aUsrNgoKlKBINmkhpCCwwxIAhsDCpBBIWhmCMMYTEhSJ4i9EgBnSBEm81MRrFBhNXEuUSMCopiRWLQqEGLNgr085M5//POS46NNYFzHQ6qGc1i5nzP/P973m/9ztCrf7A8T9csiibCocUbvTzfxLcAcaM3cY3imXz25lT3Y34G7gQYAKV3+bFAHcATlBTPogJNADG92iY28FHW97kyPbnuW/W7xgzAhukQ9xe04PJeOT0HkQRwK0TlEeGWb/kOO9v3kdD3a8YK9GhDMfa6mg9fxunOm/lWPtcpDI4K7n/jnN8+uQbrFrUSiwU/DtSEUB/MsKKBT+zYslJqiYNgVE4JwhHkzy86wlWvrKVWDSZ/YFjZlU39yw4y/rGoyQGowWB67zl4QQue+jssMdXrQvZ/00jyeHwqCgDKwnsiJjSvkYAxsG5K9WsenYbJdqAtAjhCIxCSZt/4fK1w5A2WCvxrUAKCHwNVoA2aGmvq11jJQQapEXrgMBKqmJJugejKGWLIxXrBPFoigfv/omd675gRkU/xgqUDlAhH3UDaAAlLSqUQekAYyVTyhLs3tDMsvntlIYzOFcEcOcEGd9jx9oDbGs6QO0t/Tijxi9S4bhzxiWaVh5m94Zm0n7oui4ybo0raUlcncQnxx+g+WgDF/vLoYDmoqSl/dJUnt7XRCoTZjij0Z6Pc2LiNS4EBBkNvoeOJXN+yPWWSZeANOhwJq/98nKVwNdoL8B5AROxBKBL0gjh8DMhdCh3eJnrA0yqhLpplwmyup6IajvAOIGfKGVx3VmCRGnOMpe5QAdG0bT8CAeeep0d6z6nqjSJnQiZWEllLMWrmz6k+fE9rGk8MVqYgsGv5ZH2i1Opr+9kajzB5d74hKQ+KS3d/WVMLhtgdu1lriRiOR/4nDVunaR24x7qp3UV5Cb/fJvC83nv26W81LIK58SYNFmwq4hsGx/5BwKlzYRma2NUthgOJSew4i7ru9nJYCQF5tApb2yvjiDQKJV/IfJKh0o6qssSLKv/jcAoRKHQQzE2Lj2OMV5OkWFc4MZIpsev8uXWXRx6ZicbGk8QZLxxgwe+x/rlR3h3816+f2E7lbEU+ZDn3vKVpePCdFovzCISHqbl5EIoQOteKMPB1rto65zNyfOz+KOrGl06lHPQyi/WOohH0/T0l1MZH6A3GUEKl7Pmr2la6wBrBWWRDP2DUcqjKVKBGom9RZmABAykwnglafpSJSPQvsfiOR0EQ7ExVmazA8cY6N4K1iw6RdAXRwi4mgrheT5Dvs4LeuS81a15Ll/3dQisFVSVpnj7sf1sX/sZvhAc+6UOrQyBVUQ8gx/orFmDsZqtaw/y1qZ9zKjp5vDpenyjcNe+cLNmTiUdf/bEOddVQ0VpgsOn54ET+EYxvWKALSu+5tGG76it7MNaiZKGQ23zCIcMfUMxBnrjN3fmHHvCAlp+vJcXWx6itqoXpAEnUNLx8iMfo5Xh1i17R3PJYCpC2cZ3qK3sQ8WGEDDuXlAQuFKGHzpmopXhTNfk0bmxs7uC1w6uJul79AxFkMIiBJy5UoUWjrZLU5DCFdTARDHuDqVw+OkSwI0MCEW4gtNF2BPrBCo8fKNbtILWX9aUDqFqHnn7AAAAAElFTkSuQmCC)](https://www.fnp.org.pl/en/)
  [![PL Funding](https://img.shields.io/static/v1?label=PL%20Funding%20by&color=d21132&message=NCN&logoWidth=25&logo=image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAANCAYAAACpUE5eAAAABmJLR0QA/wD/AP+gvaeTAAAAKUlEQVQ4jWP8////fwYqAiZqGjZqIHUAy4dJS6lqIOMdEZvRZDPcDQQAb3cIaY1Sbi4AAAAASUVORK5CYII=)](https://www.ncn.gov.pl/?language=en)
  [![US Funding](https://img.shields.io/static/v1?label=US%20DOE%20Funding%20by&color=267c32&message=ASR&logoWidth=25&logo=image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAB4AAAAQCAMAAAA25D/gAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAASFBMVEVOTXyyIjRDQnNZWINZWITtzdFUU4BVVIFVVYHWiZM9PG/KZnNXVoJaWYT67/FKSXhgX4hgX4lcW4VbWoX03uHQeIN2VXj///9pZChlAAAAAWJLR0QXC9aYjwAAAAd0SU1FB+EICRMGJV+KCCQAAABdSURBVBjThdBJDoAgEETRkkkZBBX0/kd11QTTpH1/STqpAAwWBkobSlkGbt0o5xmEfqxDZJB2Q6XMoBwnVSbTylWp0hi42rmbwTOYPDfR5Kc+07IIUQQvghX9THsBHcES8/SiF0kAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTctMDgtMDlUMTk6MDY6MzcrMDA6MDCX1tBgAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE3LTA4LTA5VDE5OjA2OjM3KzAwOjAw5oto3AAAAABJRU5ErkJggg==)](https://asr.science.energy.gov/)

  [![License: GPL v3](https://img.shields.io/badge/License-GPL%20v3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0.html)

  [![Github Actions Build Status](https://github.com/open-atmos/PySDM/workflows/tests+artifacts+pypi/badge.svg?branch=main)](https://github.com/open-atmos/PySDM/actions)
  [![Appveyor Build status](http://ci.appveyor.com/api/projects/status/github/open-atmos/PySDM?branch=main&svg=true)](https://ci.appveyor.com/project/slayoo/pysdm/branch/main)
  [![Coverage Status](https://codecov.io/gh/open-atmos/PySDM/branch/main/graph/badge.svg)](https://app.codecov.io/gh/open-atmos/PySDM)
  [![PyPI version](https://badge.fury.io/py/PySDM.svg)](https://pypi.org/project/PySDM)
  [![API docs](https://shields.mitmproxy.org/badge/docs-pdoc.dev-brightgreen.svg)](https://open-atmos.github.io/PySDM/)

  PySDM is a package for simulating the dynamics of population of particles.
  It is intended to serve as a building block for simulation systems modelling
    fluid flows involving a dispersed phase,
    with PySDM being responsible for representation of the dispersed phase.
  Currently, the development is focused on atmospheric cloud physics
    applications, in particular on modelling the dynamics of particles immersed in moist air
    using the particle-based (a.k.a. super-droplet) approach
    to represent aerosol/cloud/rain microphysics.
  The package features a Pythonic high-performance implementation of the
    Super-Droplet Method (SDM) Monte-Carlo algorithm for representing collisional growth
    ([Shima et al. 2009](https://rmets.onlinelibrary.wiley.com/doi/abs/10.1002/qj.441)), hence the name.

  PySDM documentation is maintained at: [https://open-atmos.github.io/PySDM](https://open-atmos.github.io/PySDM)

  There is a growing set of [example Jupyter notebooks](https://open-atmos.github.io/PySDM/PySDM_examples.html) exemplifying how to perform
    various types of calculations and simulations using PySDM.
  Most of the example notebooks reproduce results and plot from literature, see below for
    a list of examples and links to the notebooks (which can be either executed or viewed
    "in the cloud").

  There are also a growing set of [tutorials](https://github.com/open-atmos/PySDM/tree/main/tutorials), also in the form of Jupyter notebooks.
  These tutorials are intended for teaching purposes and include short explanations of cloud microphysical
    concepts paired with widgets for running interactive simulations using PySDM.
  Each tutorial also comes with a set of questions at the end that can be used as homework problems.
  Like the examples, these tutorials can be executed or viewed "in the cloud" making it an especially
    easy way for students to get started.

  PySDM has two alternative parallel number-crunching backends
    available: multi-threaded CPU backend based on [Numba](http://numba.pydata.org/)
    and GPU-resident backend built on top of [ThrustRTC](https://pypi.org/project/ThrustRTC/).
  The [`Numba`](https://open-atmos.github.io/PySDM/PySDM/backends/numba.html) backend (aliased ``CPU``) features multi-threaded parallelism for
    multi-core CPUs, it uses the just-in-time compilation technique based on the LLVM infrastructure.
  The [`ThrustRTC`](https://open-atmos.github.io/PySDM/PySDM/backends/thrust_rtc.html) backend (aliased ``GPU``) offers GPU-resident operation of PySDM
    leveraging the [SIMT](https://en.wikipedia.org/wiki/Single_instruction,_multiple_threads)
    parallelisation model.
  Using the ``GPU`` backend requires nVidia hardware and [CUDA driver](https://developer.nvidia.com/cuda-downloads).

  For an overview of PySDM features (and the preferred way to cite PySDM in papers), please refer to our JOSS papers:
  - [Bartman et al. 2022](https://doi.org/10.21105/joss.03219) (PySDM v1).
  - [de Jong, Singer et al. 2023](https://doi.org/10.21105/joss.04968) (PySDM v2).

  PySDM includes an extension of the SDM scheme to represent collisional breakup described in [de Jong, Mackay et al. 2023](10.5194/gmd-16-4193-2023).
  For a list of talks and other materials on PySDM as well as a list of published papers featuring PySDM simulations, see the [project wiki](https://github.com/open-atmos/PySDM/wiki).



  PySDM dependencies are: [Numpy](https://numpy.org/), [Numba](http://numba.pydata.org/), [SciPy](https://scipy.org/),
  [Pint](https://pint.readthedocs.io/), [chempy](https://pypi.org/project/chempy/),
  [pyevtk](https://pypi.org/project/pyevtk/),
  [ThrustRTC](https://fynv.github.io/ThrustRTC/) and [CURandRTC](https://github.com/fynv/CURandRTC).

  To install PySDM using ``pip``, use: ``pip install PySDM``
  (or ``pip install git+https://github.com/open-atmos/PySDM.git`` to get updates
  beyond the latest release).

  Conda users may use ``pip`` as well, see the [Installing non-conda packages](https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-pkgs.html#installing-non-conda-packages) section in the conda docs. Dependencies of PySDM are available at the following conda channels:
  - numba: [numba](https://anaconda.org/numba/numba)
  - conda-forge: [pyevtk](https://anaconda.org/conda-forge/pyevtk), [pint](https://anaconda.org/conda-forge/pint) and []()
  - fyplus: [ThrustRTC](https://anaconda.org/fyplus/thrustrtc), [CURandRTC](https://anaconda.org/fyplus/curandrtc)
  - bjodah: [chempy](https://anaconda.org/bjodah/chempy)
  - nvidia: [cudatoolkit](https://anaconda.org/nvidia/cudatoolkit)

  For development purposes, we suggest cloning the repository and installing it using ``pip -e``.
  Test-time dependencies can be installed with ``pip -e .[tests]``.

  PySDM examples constitute the [``PySDM-examples``](https://github.com/open-atmos/PySDM/blob/main/examples) package.
  The examples have additional dependencies listed in [``PySDM_examples`` package ``setup.py``](https://github.com/open-atmos/PySDM/blob/main/examples/setup.py) file.
  Running the example Jupyter notebooks requires the ``PySDM_examples`` package to be installed.
  The suggested install and launch steps are:
  ```
  git clone https://github.com/open-atmos/PySDM.git
  pip install -e PySDM
  pip install -e PySDM/examples
  jupyter-notebook PySDM/examples/PySDM_examples
  ```
  Alternatively, one can also install the examples package from pypi.org by
  using ``pip install PySDM-examples`` (note that this does not apply to notebooks itself,
  only the supporting .py files).




  [![Python 3](https://img.shields.io/static/v1?label=+&logo=Python&color=darkred&message=Python)](https://www.python.org/)
  [![Numba](https://img.shields.io/static/v1?label=+&logo=Numba&color=orange&message=Numba)](https://numba.pydata.org)
  [![LLVM](https://img.shields.io/static/v1?label=+&logo=LLVM&color=gold&message=LLVM)](https://llvm.org)
  [![CUDA](https://img.shields.io/static/v1?label=+&logo=nVidia&color=darkgreen&message=ThrustRTC/CUDA)](https://pypi.org/project/ThrustRTC/)
  [![NumPy](https://img.shields.io/static/v1?label=+&logo=numpy&color=blue&message=NumPy)](https://numpy.org/)
  [![pytest](https://img.shields.io/static/v1?label=+&logo=pytest&color=purple&message=pytest)](https://pytest.org/)
  [![Colab](https://img.shields.io/static/v1?label=+&logo=googlecolab&color=darkred&message=Colab)](https://colab.research.google.com/)
  [![Codecov](https://img.shields.io/static/v1?label=+&logo=codecov&color=orange&message=Codecov)](https://codecov.io/)
  [![PyPI](https://img.shields.io/static/v1?label=+&logo=pypi&color=gold&message=PyPI)](https://pypi.org/)
  [![GithubActions](https://img.shields.io/static/v1?label=+&logo=github&color=darkgreen&message=GitHub&nbsp;Actions)](https://github.com/features/actions)
  [![Jupyter](https://img.shields.io/static/v1?label=+&logo=Jupyter&color=blue&message=Jupyter)](https://jupyter.org/)
  [![PyCharm](https://img.shields.io/static/v1?label=+&logo=pycharm&color=purple&message=PyCharm)](https:///)

  Submitting new code to the project, please preferably use [GitHub pull requests](https://github.com/open-atmos/PySDM/pulls) - it helps to keep record of code authorship,
  track and archive the code review workflow and allows to benefit
  from the continuous integration setup which automates execution of tests
  with the newly added code.

  Code contributions are assumed to imply transfer of copyright.
  Should there be a need to make an exception, please indicate it when creating
  a pull request or contributing code in any other way. In any case,
  the license of the contributed code must be compatible with GPL v3.

  Developing the code, we follow [The Way of Python](https://www.python.org/dev/peps/pep-0020/) and
  the [KISS principle](https://en.wikipedia.org/wiki/KISS_principle).
  The codebase has greatly benefited from [PyCharm code inspections](https://www.jetbrains.com/help/pycharm/code-inspection.html)
  and [Pylint](https://pylint.org), [Black](https://black.readthedocs.io/en/stable/) and [isort](https://pycqa.github.io/isort/)
  code analysis (which are all part of the CI workflows).

  We also use [pre-commit hooks](https://pre-commit.com).
  In our case, the hooks modify files and re-format them.
  The pre-commit hooks can be run locally, and then the resultant changes need to be staged before committing.
  To set up the hooks locally, install pre-commit via `pip install pre-commit` and
  set up the git hooks via `pre-commit install` (this needs to be done every time you clone the project).
  To run all pre-commit hooks, run `pre-commit run --all-files`.
  The `.pre-commit-config.yaml` file can be modified in case new hooks are to be added or
    existing ones need to be altered.

  Further hints addressed at PySDM developers are maintained in the [open-atmos/python-dev-hints Wiki](https://github.com/open-atmos/python-dev-hints/wiki)
    and in [PySDM HOWTOs](https://github.com/open-atmos/PySDM/tree/main/examples/PySDM_examples/_HOWTOS).

  Issues regarding any incorrect, unintuitive or undocumented bahaviour of
  PySDM are best to be reported on the [GitHub issue tracker](https://github.com/open-atmos/PySDM/issues/new).
  Feature requests are recorded in the "Ideas..." [PySDM wiki page](https://github.com/open-atmos/PySDM/wiki/Ideas-for-new-features-and-examples).

  We encourage to use the [GitHub Discussions](https://github.com/open-atmos/PySDM/discussions) feature
  (rather than the issue tracker) for seeking support in understanding, using and extending PySDM code.

  We look forward to your contributions and feedback.



  copyright: [Jagiellonian University](https://en.uj.edu.pl/en) (2019-2023) & [AGH University of Krakow](https://agh.edu.pl/en) (2023-...)
  licence: [GPL v3](https://www.gnu.org/licenses/gpl-3.0.html)


pkgId: 6b00f8e1569fd11fd5df9420a0aa21f37e4f20592e4354cb651b9206b56b086d
name: python-PySILLS-help
arch: noarch
version: 1.0.46
epoch: 0
release: 1
summary: Development documents and examples for PySILLS
url: https://github.com/MABeeskow/PySILLS
rpm_license: LGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PySILLS-1.0.46-1.src.rpm
location_href: Packages/python-PySILLS-help-1.0.46-1.noarch.rpm
checksum_type: sha256
description:
  I am aware of the fact that there are still some bugs and some of them can also cause a crash of the program. But, those
  bugs are the reason why I have decided to publish this pre-release version, because, as a developer, I see everywhere
  construction sites in the code, but I would like to know which ones are the most important. So, it is possible that
  different users have different ideas how a mineral or fluid inclusion analysis project should be done. I have developed
  PySILLS with my workflow in my mind. Now, the goal is to make it also applicable for your workflow.
  Let's catch the bugs and smash them! ð

  It was necessary to apply some changes concerning the saving/loading algorithm of a project. It is possible that an
  imported project does not contain any information about the acquisition time of the single measurement files. It is
  necessary to add them manually, to save the project again and to restart it finally again. If the user does not restart
  the project, it is possible that further bugs occur.

  A detailed manual about the installation of PySILLS can be found [here](https://docs.google.com/document/d/18nw22PvVRpJvcUNXSThIvXpVhTG6ePhRhZph0nDWVaY/edit?usp=sharing).
  PySILLS can be easily installed via the following command:
  <code>pip install PySILLS</code>
  Alternatively, it is possible to run PySILLS by a manual installation of Python and - if not already installed - the
  following packages:
  * numpy
  * scipy
  * pandas
  * matplotlib
  * sympy
  * (tkinter)
  In some cases, it will be necessary to install tkinter manually although it should be actually already part of your
  python version.
  ![Python](https://img.shields.io/badge/python-3670A0?style=for-the-badge&logo=python&logoColor=ffdd54) &nbsp;
  ![NumPy](https://img.shields.io/badge/numpy-%23013243.svg?style=for-the-badge&logo=numpy&logoColor=white) &nbsp;
  ![SciPy](https://img.shields.io/badge/SciPy-%230C55A5.svg?style=for-the-badge&logo=scipy&logoColor=%white) &nbsp;
  ![Pandas](https://img.shields.io/badge/pandas-%23150458.svg?style=for-the-badge&logo=pandas&logoColor=white) &nbsp;
  ![Matplotlib](https://img.shields.io/badge/Matplotlib-%23ffffff.svg?style=for-the-badge&logo=Matplotlib&logoColor=black)
  ![Sympy](https://img.shields.io/badge/SymPy-3B5526.svg?style=for-the-badge&logo=SymPy&logoColor=white) &nbsp;
  ![Windows](https://img.shields.io/badge/Windows-0078D6?style=for-the-badge&logo=windows&logoColor=white) &nbsp;
  ![macOS](https://img.shields.io/badge/mac%20os-000000?style=for-the-badge&logo=macos&logoColor=F0F0F0) &nbsp;
  ![Linux](https://img.shields.io/badge/Linux-FCC624?style=for-the-badge&logo=linux&logoColor=black)

  PySILLS can be started by running the command <code> python pysills_app.py </code>. If possible, use the newest version
  of PySILLS.

  There is unfortunately a bug concerning the GUI library tkinter and default Python version that is installed on a Mac.
  You will notice this bug for example when you click on a button and for some cases, it will work directly, and for other
  cases, you have to click several times on the button or after moving the window a little bit.
  In order to avoid this bug, there is the following workaround until Apple will fix this one day:
  1) Install the newest version of PySILLS (it will work with Python 3.12). There are several ways to do this but I would
  recommend to install it via Homebrew which is a package manager for Mac OS.
  2) Install all needed packages explicitly for this newly installed Python version, for example via pip. Example command
  for the installation of numpy for Python 3.12: <code> python3.12 -m pip install numpy </code>.
  3) If you run PySILLS now by the command <code> python3.12 pysills_app.py </code>, the previously described bug should
  not appear anymore!

  [PySILLS manual (installation)](https://docs.google.com/document/d/18nw22PvVRpJvcUNXSThIvXpVhTG6ePhRhZph0nDWVaY/)\
  [PySILLS manual (mineral analysis)](https://docs.google.com/document/d/1u5CkBJiXBnhqsdh7ooiEncuexeBWgP6WDg5X2Am6bOA/)\
  [PySILLS manual (fluid inclusion analysis)](https://docs.google.com/document/d/1GeK4aQaiP3D1Na_-7ZUZiBLfzr0wK2mq2888VtTlZIY/)\
  [PySILLS manual (melt inclusion analysis)](https://docs.google.com/document/d/15PcfBwTK-dGnMUEiuOhYsKcNpWurOAWnUiKUSeNjtN8/)
  [PySILLS on ReadTheDocs](https://pysills.readthedocs.io/en/latest/)\
  [PySILLS on Blogger](https://pysills.blogspot.com/)\
  [PySILLS on YouTube](https://www.youtube.com/@PySILLS)\
  [PySILLS on PyPi](https://pypi.org/project/PySILLS/)
  ![Blogger](https://img.shields.io/badge/Blogger-FF5722?style=for-the-badge&logo=blogger&logoColor=white) &nbsp;
  ![YouTube](https://img.shields.io/badge/YouTube-%23FF0000.svg?style=for-the-badge&logo=YouTube&logoColor=white)

  Coming soon ...


pkgId: 451a4042f04c394385a6a53cd27a7dab08cb799f08d9af883a69a84616e6b527
name: python-PySciVisToolKit-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for PySciVisToolKit
url: https://pypi.org/project/PySciVisToolKit/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PySciVisToolKit-0.0.3-1.src.rpm
location_href: Packages/python-PySciVisToolKit-help-0.0.3-1.noarch.rpm
checksum_type: sha256
description:
  A simple CLI tool to tackle some easy tasks during writing SciVis paper. Still under developing.


  ```bash
  pip install PySciVisToolKit
  ```


pkgId: 158a688f7f043a47ab0002639902b5cc746928f227f4183b8be54d70fc3b38fa
name: python-PySimultan-help
arch: noarch
version: 0.5.9
epoch: 0
release: 1
summary: Development documents and examples for PySimultan
url: https://pypi.org/project/PySimultan/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PySimultan-0.5.9-1.src.rpm
location_href: Packages/python-PySimultan-help-0.5.9-1.noarch.rpm
checksum_type: sha256
description:
  - [Installation](#installation)
  - [License](#license)
  - [Usage](#usage)
  - [Change Log](#change-log)

  ```console
  pip install PySimultan
  ```

  `PySimultan` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.


  Create a new data model:
  ```python
  from PySimultan2 import DataModel

  data_model = DataModel.create_new_project(project_path='my_project.simultan',
                                            user_name='admin',
                                            password='admin')
  ```
  Load an existing data model:
  ```python
  from PySimultan2 import DataModel

  data_model = DataModel(project_path='my_project.simultan',
                         user_name='admin',
                         password='admin')
  ```
  save the data model:
  ```python
  data_model.save()
  ```
  close and cleanup the data model:
  ```python
  data_model.cleanup()
  ```


  ```python
  from PySimultan2 import DataModel, TaxonomyMap, Content, PythonMapper
  mapper = PythonMapper()
  class TestComponent(object):
      def __init__(self, *args, **kwargs):
          self.param_1 = kwargs.get('param_1')
          self.param_2 = kwargs.get('param_2')
  content0 = Content(text_or_key='param_1',  # text or key of the content/parameter/property
                     property_name='param_1',  # name of the generated property
                     type=None,  # type of the content/parameter/property
                     unit=None,  # unit of the content/parameter/property
                     documentation='param_1 to test')
  content1 = Content(text_or_key='param_2',  # text or key of the content/parameter/property
                     property_name='param_2',  # name of the generated property
                     type=None,  # type of the content/parameter/property
                     unit=None,  # unit of the content/parameter/property
                     documentation='param_2 to test')
  test_component_map = TaxonomyMap(taxonomy_name='PySimultan',
                                   taxonomy_key='Test',
                                   taxonomy_entry_name='test_component',
                                   taxonomy_entry_key='test_component',
                                   content=[content0, content1],
                                   )
  mapper.register(test_component_map.taxonomy_entry_key, TestComponent, taxonomy_map=test_component_map)
  ```

  ```python

  mapped_test_component_cls = mapper.get_mapped_class('test_component')

  mapped_test_component = mapped_test_component_cls(param_1='value1',
                                                    param_2='value2',
                                                    data_model=data_model)

  data_model.save()

  data_model.cleanup()
  ```

  ```python

  data_model = DataModel(project_path='my_project.simultan',
                         user_name='admin',
                         password='admin')

  mapped_test_component_cls = mapper.get_mapped_class('test_component')

  instances = mapped_test_component_cls.cls_instaces
  print(instances[0].param_1)
  ```


  - Added FileInfo.from_existing_file method to create FileInfo object from existing file in ProjectUnpackFolder

  - Added support for different taxonomy for content
  - Added support for numpy np.float32, np.float64 and np.int32, np.int64

  - Fixed Bug in nested dictionary creation

  - Refactored dictionaries


pkgId: 30b7017ee30940862c982385226138c4509ed5e224f7c79dac4876972c9ec836
name: python-PyStellarDB-help
arch: noarch
version: 0.13.5
epoch: 0
release: 1
summary: Development documents and examples for PyStellarDB
url: https://github.com/WarpCloud/PyStellarDB
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyStellarDB-0.13.5-1.src.rpm
location_href: Packages/python-PyStellarDB-help-0.13.5-1.noarch.rpm
checksum_type: sha256
description:
  PyStellarDB is a Python API for executing Transwarp Exetended OpenCypher(TEoC) and Hive query.
  It could also generate a RDD object which could be used in PySpark.
  It is base on PyHive(https://github.com/dropbox/PyHive) and PySpark(https://github.com/apache/spark/)


pkgId: 2a405546dbdca515c858d95322a0f7d4f865592b12017acef14a9e6ccfe2aa53
name: python-PyTDC-help
arch: noarch
version: 1.1.2
epoch: 0
release: 1
summary: Development documents and examples for PyTDC
url: https://github.com/mims-harvard/TDC
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyTDC-1.1.2-1.src.rpm
location_href: Packages/python-PyTDC-help-1.1.2-1.noarch.rpm
checksum_type: sha256
description:
  [![website](https://img.shields.io/badge/website-live-brightgreen)](https://tdcommons.ai)
  [![PyPI version](https://badge.fury.io/py/PyTDC.svg)](https://badge.fury.io/py/PyTDC)
  [![Downloads](https://pepy.tech/badge/pytdc/month)](https://pepy.tech/project/pytdc)
  [![Downloads](https://pepy.tech/badge/pytdc)](https://pepy.tech/project/pytdc)
  [![GitHub Repo stars](https://img.shields.io/github/stars/mims-harvard/TDC)](https://github.com/mims-harvard/TDC/stargazers)
  [![GitHub Repo stars](https://img.shields.io/github/forks/mims-harvard/TDC)](https://github.com/mims-harvard/TDC/network/members)
  [![TDC CircleCI](https://circleci.com/gh/mims-harvard/TDC.svg?style=svg)](https://app.circleci.com/pipelines/github/mims-harvard/TDC)
  ![Conda Github Actions Build](https://github.com/mims-harvard/TDC/actions/workflows/conda-tests.yml/badge.svg)
  [![Documentation Status](https://readthedocs.org/projects/tdc/badge/?version=latest)](http://tdc.readthedocs.io/?badge=latest)
  [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
  [![Twitter](https://img.shields.io/twitter/url/https/twitter.com/cloudposse.svg?style=social&label=Follow%20%40ProjectTDC)](https://twitter.com/ProjectTDC)
  [**Website**](https://tdcommons.ai) | [**Nature Chemical Biology 2022 Paper**](https://www.nature.com/articles/s41589-022-01131-2) | [**NeurIPS 2021 Paper**](https://openreview.net/pdf?id=8nvgnORnoWr) | [**Long Paper**](https://arxiv.org/abs/2102.09548) | [**Slack**](https://join.slack.com/t/pytdc/shared_invite/zt-x0ujg5v6-zwtQZt83fhRdgrYjXRFz5g) | [**TDC Mailing List**](https://groups.io/g/tdc) | [**TDC Documentation**](https://tdc.readthedocs.io/) | [**Contribution Guidelines**](CONTRIBUTE.md)
  Artificial intelligence is poised to reshape therapeutic science. **Therapeutics Data Commons** is a coordinated initiative to access and evaluate artificial intelligence capability across therapeutic modalities and stages of discovery, supporting the development of AI methods, with a strong bent towards establishing the foundation of which AI methods are most suitable for drug discovery applications and why.
  Researchers across disciplines can use TDC for numerous applications. AI-solvable tasks, AI-ready datasets, and curated benchmarks in TDC serve as a meeting point between biochemical and AI scientists. TDC facilitates algorithmic and scientific advances and accelerates machine learning method development, validation, and transition into biomedical and clinical implementation.
  TDC is an open-science initiative. We welcome [contributions from the community.](CONTRIBUTE.md)

  [1] Velez-Arce, Huang, Li, Lin, et al., TDC-2: Multimodal Foundation for Therapeutic Science, bioRxiv, 2024 [**\[Paper\]**](https://www.biorxiv.org/content/10.1101/2024.06.12.598655v2)
  [2] Huang, Fu, Gao, et al., Artificial Intelligence Foundation for Therapeutic Science, Nature Chemical Biology, 2022 [**\[Paper\]**](https://www.nature.com/articles/s41589-022-01131-2)
  [3] Huang, Fu, Gao, et al., Therapeutics Data Commons: Machine Learning Datasets and Tasks for Drug Discovery and Development, NeurIPS 2021 [**\[Paper\]**](https://openreview.net/forum?id=8nvgnORnoWr) [**\[Poster\]**](https://drive.google.com/file/d/1LfF8mfPLUqAVEzH3KPBxDO_VF7nLFtiJ/view?usp=sharing)
  [4] Huang et al., Benchmarking Molecular Machine Learning in Therapeutics Data Commons, ELLIS ML4Molecules 2021 [**\[Paper\]**](https://cloud.ml.jku.at/s/54pB5Eqf6ftX7qA) [**\[Slides\]**](https://drive.google.com/file/d/1iOSW_5eruca4vdygDxS1H64c49oQuH40/view?usp=sharing)
  [5] Huang et al., Therapeutics Data Commons: Machine Learning Datasets and Tasks for Drug Discovery and Development, Baylearn 2021 [**\[Slides\]**](https://drive.google.com/file/d/1BNpk3dOdqE3ksgyVV-V3xySdBMq-8cXL/view?usp=sharing) [**\[Poster\]**](https://drive.google.com/file/d/1LfF8mfPLUqAVEzH3KPBxDO_VF7nLFtiJ/view?usp=sharing)
  [6] Huang, Fu, Gao et al., Therapeutics Data Commons, NSF-Harvard Symposium on Drugs for Future Pandemics 2020 [**\[#futuretx20\]**](https://www.drugsymposium.org/) [**\[Slides\]**](https://drive.google.com/file/d/11eTrh_lsqPcwu3RZRYjJGNpJ3s18YlBS/view) [**\[Video\]**](https://youtu.be/ZuCOhEZtaOw)
  [7] [TDC User Group Meetup, Jan 2022](https://harvard.zoom.us/rec/share/HO0TjRPs56YG-Fu3i033izaTwebB4KwUhPeNURkWSI-anrH9su03lCtUlHeZG-WP.67ZJmAIHsD7Q_2GQ) [**\[Agenda\]**](https://shoutout.wix.com/so/d1Nv1pC2d#/main)
  [8] Zitnik, Machine Learning to Translate the Cancer Genome and Epigenome Session, [AACR Annual Meeting 2022, Apr 2022](https://www.aacr.org/meeting/aacr-annual-meeting-2022/)
  [9] Zitnik, Few-Shot Learning for Network Biology, [Keynote at KDD Workshop on Data Mining in Bioinformatics](https://biokdd.org/biokdd21/keynote.html)
  [10] Zitnik, Actionable machine learning for drug discovery and development, [Broad Institute, Models, Inference & Algorithms Seminar, 2021](https://www.broadinstitute.org/talks/actionable-machine-learning-drug-discovery-and-development)
  [11] Zitnik, Graph Neural Networks for Biomedical Data, [Machine Learning in Computational Biology, 2020](https://sites.google.com/cs.washington.edu/mlcb2020/schedule?authuser=0)
  [12] Zitnik, Graph Neural Networks for Identifying COVID-19 Drug Repurposing Opportunities, [MIT AI Cures, 2020](https://www.aicures.mit.edu/drugdiscoveryconference)

  - *Diverse areas of therapeutics development*: TDC covers a wide range of learning tasks, including target discovery, activity screening, efficacy, safety, and manufacturing across biomedical products, including small molecules, antibodies, and vaccines.
  - *Ready-to-use datasets*: TDC is minimally dependent on external packages. Any TDC dataset can be retrieved using only 3 lines of code.
  - *Data functions*: TDC provides extensive data functions, including data evaluators, meaningful data splits, data processors, and molecule generation oracles.
  - *Leaderboards*: TDC provides benchmarks for fair model comparison and systematic model development and evaluation.
  - *Open-source initiative*: TDC is an open-source initiative. If you want to get involved, let us know.
  <p align="center"><img src="https://raw.githubusercontent.com/mims-harvard/TDC/master/fig/tdc_overview.png" alt="overview" width="600px" /></p>
  See [here](https://tdcommons.ai/news/) for the latest updates in TDC!


  To install the core environment dependencies of TDC, use `pip`:
  ```bash
  pip install PyTDC
  ```
  **Note**: TDC is in the beta release. Please update your local copy regularly by
  ```bash
  pip install PyTDC --upgrade
  ```
  The core data loaders are lightweight with minimum dependency on external packages:
  ```bash
  numpy, pandas, tqdm, scikit-learn, fuzzywuzzy, seaborn
  ```

  We provide  tutorials to get started with TDC:
  | Name  | Description                                             |
  |-------|---------------------------------------------------------|
  | [101](tutorials/TDC_101_Data_Loader.ipynb)   | Introduce TDC Data Loaders                              |
  | [102](tutorials/TDC_102_Data_Functions.ipynb)   | Introduce TDC Data Functions                            |
  | [103.1](tutorials/TDC_103.1_Datasets_Small_Molecules.ipynb) | Walk through TDC Small Molecule Datasets                |
  | [103.2](tutorials/TDC_103.2_Datasets_Biologics.ipynb) | Walk through TDC Biologics Datasets                     |
  | [104](tutorials/TDC_104_ML_Model_DeepPurpose.ipynb)   | Generate 21 ADME ML Predictors with 15 Lines of Code |
  | [105](tutorials/TDC_105_Oracle.ipynb)   | Molecule Generation Oracles                             |
  | [106](tutorials/TDC_106_BenchmarkGroup_Submission_Demo.ipynb)   | Benchmark submission                             |
  | [DGL](tutorials/DGL_User_Group_Demo.ipynb)   | Demo presented at DGL GNN User Group Meeting                             |
  | [U1.1](tutorials/User_Group/UserGroupMeeting_Tianfan.ipynb)   | Demo presented at first TDC User Group Meetup                             |
  | [U1.2](tutorials/User_Group/UserGroupMeeting_Wenhao.ipynb)   | Demo presented at first TDC User Group Meetup                             |
  | [201](https://colab.research.google.com/drive/1xTgBwKUfP2b8j6Fqh28M2GUp2ScfENMX?usp=sharing) | TDC-2 Resource and Multi-modal Single-Cell API |
  | [202](https://colab.research.google.com/drive/1kYH8nt3nW7tXYBPNcfYuDbWxGTqOEnWg?usp=sharing) | TDC-2 Resource and PrimeKG |
  | [203](https://colab.research.google.com/drive/13MYlg5tWpywWbKYsJQXafKAlVF2hz-sP?usp=sharing) | TDC-2 Resource and External APIs |
  | [204](https://colab.research.google.com/drive/17Pd328W27mn-iBCRkHIa78L3pukKcfW1?usp=sharing) | TDC-2 Model Hub |
  | [205](https://colab.research.google.com/drive/1kHdFG4gUic5nmiul7b1hUh0HLCxLQnw_?usp=sharing) | TDC-2 Molecular Property Cliff Prediction Task |

  TDC has a unique three-tiered hierarchical structure, which to our knowledge, is the first attempt at systematically organizing machine learning for therapeutics. We organize TDC into three distinct *problems*. For each problem, we give a collection of *learning tasks*. Finally, for each task, we provide a series of *datasets*.
  In the first tier, after observing a large set of therapeutics tasks, we categorize and abstract out three major areas (i.e., problems) where machine learning can facilitate scientific advances, namely, single-instance prediction, multi-instance prediction, and generation:
  * Single-instance prediction `single_pred`: Prediction of property given individual biomedical entity.
  * Multi-instance prediction `multi_pred`: Prediction of property given multiple biomedical entities.
  * Generation `generation`: Generation of new desirable biomedical entities.
  <p align="center"><img src="https://raw.githubusercontent.com/mims-harvard/TDC/master/fig/tdc_problems.png" alt="problems" width="500px" /></p>
  The second tier in the TDC structure is organized into learning tasks. Improvement in these tasks can result in numerous applications, including identifying personalized combinatorial therapies, designing novel classes of antibodies, improving disease diagnosis, and finding new cures for emerging diseases.
  Finally, in the third tier of TDC, each task is instantiated via multiple datasets. For each dataset, we provide several splits of the dataset into training, validation, and test sets to simulate the type of understanding and generalization (e.g., the model's ability to generalize to entirely unseen compounds or to granularly resolve patient response to a polytherapy) needed for transition into production and clinical implementation.

  TDC provides a collection of workflows with intuitive, high-level APIs for both beginners and experts to create machine learning models in Python. Building off the modularized "Problem -- Learning Task -- Data Set" structure (see above) in TDC, we provide a three-layer API to access any learning task and dataset. This hierarchical API design allows us to easily incorporate new tasks and datasets.
  For a concrete example, to obtain the HIA dataset from the ADME therapeutic learning task in the single-instance prediction problem:
  ```python
  from tdc.single_pred import ADME
  data = ADME(name = 'HIA_Hou')

  split = data.get_split(method = 'scaffold')

  data.get_data(format = 'df')
  ```
  You can see all the datasets that belong to a task as follows:
  ```python
  from tdc.utils import retrieve_dataset_names
  retrieve_dataset_names('ADME')
  ```
  See all therapeutic tasks and datasets on the [TDC website](https://zitniklab.hms.harvard.edu/TDC/overview/)!


  To retrieve the training/validation/test dataset split, you could simply type
  ```python
  data = X(name = Y)
  data.get_split(seed = 42)

  ```
  You can specify the splitting method, random seed, and split fractions in the function by e.g. `data.get_split(method = 'scaffold', seed = 1, frac = [0.7, 0.1, 0.2])`. Check out the [data split page](https://zitniklab.hms.harvard.edu/TDC/functions/data_split/) on the website for details.

  We provide various evaluation metrics for the tasks in TDC, which are described in [model evaluation page](https://zitniklab.hms.harvard.edu/TDC/functions/data_evaluation/) on the website. For example, to use metric ROC-AUC, you could simply type
  ```python
  from tdc import Evaluator
  evaluator = Evaluator(name = 'ROC-AUC')
  score = evaluator(y_true, y_pred)
  ```

  TDC provides numerous data processing functions, including label transformation, data balancing, pairing data to PyG/DGL graphs, negative sampling, database querying, and so on. For function usage, see our [data processing page](https://zitniklab.hms.harvard.edu/TDC/functions/data_process/) on the TDC website.

  For molecule generation tasks, we provide 10+ oracles for both goal-oriented and distribution learning. For detailed usage of each oracle, please check out the [oracle page](https://zitniklab.hms.harvard.edu/TDC/functions/oracles/) on the website. For example, we want to retrieve the GSK3Beta oracle:
  ```python
  from tdc import Oracle
  oracle = Oracle(name = 'GSK3B')
  oracle(['CC(C)(C)....'
    'C[C@@H]1....',
    'CCNC(=O)....',
    'C[C@@H]1....'])

  ```

  Every dataset in TDC is a benchmark, and we provide training/validation and test sets for it, together with data splits and performance evaluation metrics. To participate in the leaderboard for a specific benchmark, follow these steps:
  * Use the TDC benchmark data loader to retrieve the benchmark.
  * Use training and/or validation set to train your model.
  * Use the TDC model evaluator to calculate the performance of your model on the test set.
  * Submit the test set performance to a TDC leaderboard.
  As many datasets share a therapeutics theme, we organize benchmarks into meaningfully defined groups, which we refer to as benchmark groups. Datasets and tasks within a benchmark group are carefully curated and centered around a theme (for example, TDC contains a benchmark group to support ML predictions of the ADMET properties). While every benchmark group consists of multiple benchmarks, it is possible to separately submit results for each benchmark in the group. Here is the code framework to access the benchmarks:
  ```python
  from tdc import BenchmarkGroup
  group = BenchmarkGroup(name = 'ADMET_Group', path = 'data/')
  predictions_list = []
  for seed in [1, 2, 3, 4, 5]:
      benchmark = group.get('Caco2_Wang')
      
      predictions = {}
      name = benchmark['name']
      train_val, test = benchmark['train_val'], benchmark['test']
      train, valid = group.get_train_valid_split(benchmark = name, split_type = 'default', seed = seed)
          
          
          
          
      predictions[name] = y_pred_test
      predictions_list.append(predictions)
  results = group.evaluate_many(predictions_list)

  ```
  For more information, visit [here](https://tdcommons.ai/benchmark/overview/).

  If you find Therapeutics Data Commons useful, cite our [NeurIPS paper](https://openreview.net/forum?id=kL8dlYp6IM), and [Nature Chemical Biology paper](https://www.nature.com/articles/s41589-022-01131-2) :
  ```
  @inproceedings{
  velez-arce2024signals,
  title={Signals in the Cells: Multimodal and Contextualized Machine Learning Foundations for Therapeutics},
  author={Alejandro Velez-Arce and Kexin Huang and Michelle M Li and xiang lin and Wenhao Gao and Bradley Pentelute and Tianfan Fu and Manolis Kellis and Marinka Zitnik},
  booktitle={NeurIPS 2024 Workshop on AI for New Drug Modalities},
  year={2024},
  url={https://openreview.net/forum?id=kL8dlYp6IM}
  }
  ```
  ```
  @article{Huang2022artificial,
    title={Artificial intelligence foundation for therapeutic science},
    author={Huang, Kexin and Fu, Tianfan and Gao, Wenhao and Zhao, Yue and Roohani, Yusuf and Leskovec, Jure and Coley,
            Connor W and Xiao, Cao and Sun, Jimeng and Zitnik, Marinka},
    journal={Nature Chemical Biology},
    year={2022}
  }
  ```
  TDC is built on top of other open-sourced projects. If you used these datasets/functions in your research, please cite the original work as well. You can find the original paper on the website for the function/dataset.

  TDC is a community-driven and open-science initiative. To get involved, join our [Slack Workspace](https://join.slack.com/t/pytdc/shared_invite/zt-x0ujg5v6-zwtQZt83fhRdgrYjXRFz5g) and check out the [contribution guide](CONTRIBUTE.md)!

  Reach us at [contact@tdcommons.ai](mailto:contact@tdcommons.ai) or open a GitHub issue.

  TDC is hosted on [Harvard Dataverse](https://dataverse.harvard.edu/dataset.xhtml?persistentId=doi:10.7910/DVN/21LKWG) with the following persistent identifier [https://doi.org/10.7910/DVN/21LKWG](https://doi.org/10.7910/DVN/21LKWG). When Dataverse is under maintenance, TDC datasets cannot be retrieved. That happens rarely; please check the status on [the Dataverse website](https://dataverse.harvard.edu/).

  TDC codebase is under MIT license. For individual dataset usage, please refer to the dataset license found in the website.


pkgId: 7108184f14b29472e4f9e67e1d112ed27b89d9749b4f4f8f5ca97544ef239614
name: python-PyTestingQA-help
arch: noarch
version: 2.2.1
epoch: 0
release: 1
summary: Development documents and examples for PyTestingQA
url: https://github.com/CyberCoral/PyTesting
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyTestingQA-2.2.1-1.src.rpm
location_href: Packages/python-PyTestingQA-help-2.2.1-1.noarch.rpm
checksum_type: sha256
description:
  A Python library that contains tools for unit testing.


  To use the project, you have two options:


  If you execute the program as a main module, it will
  print a small description of the project.


  Instead, if you import the module to your project or
  you build your own code on the library's file, you will
  be able to use it directly.


pkgId: 0e4b0372261be97409e933146edd771856063f923f3bd0f10558951fa8db8375
name: python-PyThermoDB-help
arch: noarch
version: 1.7.0
epoch: 0
release: 1
summary: Development documents and examples for PyThermoDB
url: https://pypi.org/project/PyThermoDB/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyThermoDB-1.7.0-1.src.rpm
location_href: Packages/python-PyThermoDB-help-1.7.0-1.noarch.rpm
checksum_type: sha256
description:
  ![PyThermoDB](https://drive.google.com/uc?export=view&id=1-yWNEkK4tL1qvi8FE_4OwcLYuTF2AkPP)

  ![Downloads](https://img.shields.io/pypi/dm/PyThermoDB) ![PyPI](https://img.shields.io/pypi/v/PyThermoDB) ![Python Version](https://img.shields.io/pypi/pyversions/PyThermoDB.svg) ![License](https://img.shields.io/pypi/l/PyThermoDB) ![Read the Docs](https://img.shields.io/readthedocs/pythermodb)

  Python Thermodynamics Databook

  PyThermoDB is a lightweight and user-friendly Python package designed to provide quick access to essential thermodynamic data. Whether you're a student, researcher, or engineer, this package serves as a valuable resource for retrieving thermodynamic properties, equations, and constants from your `custom thermodynamic database` (csv files).

  Key Features:

  - **Handbook Data**: The package sources its data from well-established thermodynamics handbooks, ensuring accuracy and reliability (*updated regularly*).
  - **Custom Thermodynamic Database**: It is possible to builtin your own thermodynamic databook for your project.
  - **Minimal Dependencies**: Built with simplicity in mind, the package has minimal external dependencies, making it easy to integrate into your projects.
  - **Open Source**: Feel free to explore, contribute, and customize the package according to your needs.



  You can check the thermoDB files in the following link:

  - [⏩thermodb-demo](https://pythermodb-demo.streamlit.app/)



  You can use the following code to run `PyThermoDB` in Google Colab:

  | Version | Scripts |
  |---------|---------|
  | 1.6.0 | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1vj84afCy0qKfHZzQdvLiJRiVstiCX0so?usp=sharing) |
  | 1.5.0 | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1jWkaSJ280AZFn9t8X7_bqz_pYtY2QKbr?usp=sharing) |

  **Examples on Google Colab**

  | Example | Scripts |
  |---------|---------|
  | CO₂ Thermodynamic Data | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1mzu70kACdvoB_jO6gTGVegGtK_ssOOHq?usp=sharing) |
  | Check Component Availability | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1HdGHS_uypEf_yzsq7fZyLZH3dWnjYVSg?usp=sharing) |



  Install PyThermoDB with pip

  ```python
  import pyThermoDB as ptdb

  print(ptdb.__version__)
  ```



  * databook reference initialization:

  ```python

  tdb = ptdb.init()
  ```

  * DATABOOK LIST:

  ```python

  db_list = tdb.list_databooks()
  print(db_list)
  ```

  * TABLE LIST:

  ```python

  tb_lists = tdb.list_tables(1)
  print(tb_lists)
  ```

  * TABLE INFO:

  ```python

  tb_info = tdb.table_info(1, 2)
  print(tb_info)
  ```

  * LOAD TABLES (before building):

  ```python

  vapor_pressure_tb = tdb.equation_load(1, 4)
  pp(vapor_pressure_tb.eq_structure(1))

  data_table = tdb.data_load(1, 2)
  pp(data_table.data_structure())
  ```

  * CHECK COMPONENT AVAILABILITY IN A TABLE:

  ```python

  comp1 = "carbon Dioxide"





  ```

  * BUILD DATA OBJECT:

  ```python

  CO2_data = tdb.build_data(comp1, 1, 2)
  pp(CO2_data.data_structure())
  pp(CO2_data.get_property(4))
  ```

  * BUILD EQUATION OBJECT:

  ```python

  eq = tdb.build_equation(comp1, 1, 4)
  pp(eq.args)
  res = eq.cal(T=298.15)
  pp(res*1e-5)
  ```



  DataTable & EquationTable saved as an object in `Carbon Dioxide.pkl`

  * BUILD THERMODB:

  ```python

  thermo_db = ptdb.build_thermodb()
  pp(type(thermo_db))


  thermo_db.add_data('general', comp1_data)

  thermo_db.add_data('heat-capacity', comp1_eq)
  thermo_db.add_data('vapor-pressure', vapor_pressure_eq)





  thermo_db.save(
      f'{comp1}', file_path='E:\\Python Projects\\pyThermoDB\\tests')
  ```

  * CHECK THERMODB:

  ```python

  pp(thermo_db.check_properties())
  pp(thermo_db.check_functions())
  ```



  `Carbon Dioxide.pkl` can be loaded as:

  * LOAD THERMODB

  ```python

  thermodb_file = 'Carbon Dioxide.pkl'
  thermodb_path = os.path.join(os.getcwd(), thermodb_file)
  pp(thermodb_path)
  ```

  * LOAD THERMODB

  ```python

  CO2_thermodb = ptdb.load_thermodb(thermodb_path)
  pp(type(CO2_thermodb))
  ```

  * CHECK THERMODB

  ```python

  pp(CO2_thermodb.check())
  ```



  * Step 1:

  Modify `yml file` by adding `CUSTOM-INTEGRAL`.

  * Step 2:

  Add a name for the new integral body.

  * Step 3:

  Add a list containing the integral body.

  ```yml
  CUSTOM-INTEGRAL:
      Cp/R:
          - A1 = parms['a0']*args['T1']
          - B1 = (parms['a1']/2)*(args['T1']**2)
          - C1 = (parms['a2']/3)*(args['T1']**3)
          - D1 = (parms['a3']/4)*(args['T1']**4)
          - E1 = (parms['a4']/5)*(args['T1']**5)
          - res1 =  A1 + B1 + C1 + D1 + E1
          - A2 = parms['a0']*args['T2']
          - B2 = (parms['a1']/2)*(args['T2']**2)
          - C2 = (parms['a2']/3)*(args['T2']**3)
          - D2 = (parms['a3']/4)*(args['T2']**4)
          - E2 = (parms['a4']/5)*(args['T2']**5)
          - res2 =  A2 + B2 + C2 + D2 + E2
          - res = res2 - res1
  ```

  * CHECK AS:

  ```python

  pp(comp1_eq.custom_integral)

  pp(comp1_eq.check_custom_integral_equation_body('Cp/R'))


  Cp_cal_custom_integral_Cp__R = comp1_eq.cal_custom_integral(
      'Cp/R', T1=298.15, T2=320)
  pp(Cp_cal_custom_integral_Cp__R)
  ```



  For any question, contact me on [LinkedIn](https://www.linkedin.com/in/sina-gilassi/)




  - [@sinagilassi](https://www.github.com/sinagilassi)


pkgId: a7cd03d49d88975c312f88c187e223d64296355025ba1212f545390154103c28
name: python-PyViCare-help
arch: noarch
version: 2.38.0
epoch: 0
release: 1
summary: Development documents and examples for PyViCare
url: https://github.com/openviess/PyViCare
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyViCare-2.38.0-1.src.rpm
location_href: Packages/python-PyViCare-help-2.38.0-1.noarch.rpm
checksum_type: sha256
description:
  This library implements access to Viessmann devices by using the official API from the [Viessmann Developer Portal](https://developer.viessmann.com/).



  - Some base classes have been renamed to provide a better support for non heating devices. See [PR #307](https://github.com/somm15/PyViCare/pull/307)



  - The circuit, burner (Gaz) and compressor (Heat Pump) is now separated. Accessing the properties of the burner/compressor is moved from `device.circuits` to `device.burners` and `device.compressor`.



  - The API to access your device changed to a general `PyViCare` class. Use this class to load all available devices.
  - The API to access the heating circuit of the device has moved to the `Device` class. You can now access and iterate over all available circuits via `device.circuits`. This allows to easily see which properties are depending on the circuit.

  See the example below for how you can use that.



  - The versions prior to 1.x used an unofficial API which stopped working on July, 15th 2021. All users need to migrate to version 1.0.0 to continue using the API.
  - Exception is raised if the library runs into a API rate limit. (See feature flag `raise_exception_on_rate_limit`)
  - Exception is raised if an unsupported device feature is used. (See feature flag `raise_exception_on_not_supported_device_feature`)
  - Python 3.4 is no longer supported.
  - Python 3.9 is now supported.



  To use PyViCare, every user has to register and create their personal API client. Follow these steps to create your client:

  1. Login to the [Viessmann Developer Portal](https://app.developer.viessmann.com/) with **your existing ViCare app username/password**.
  2. On the developer dashboard click *add* in the *clients* section.
  3. Create a new client using following data:
     - Name: PyViCare
     - Google reCAPTCHA: Disabled
     - Redirect URIs: `vicare://oauth-callback/everest`
  4. Copy the `Client ID` to use in your code. Pass it as constructor parameter to the device.

  Please note that not all properties from older versions and the ViCare mobile app are available in the new API. Missing properties were removed and might be added later if they are available again.



  We need help testing and improving PyViCare, since the maintainers only have specific types of heating systems. For bugs, questions or feature requests join the [PyViCare channel on Discord](https://discord.gg/aM3SqCD88f) or create an issue in this repository.



  Depending on the device, some features are not available/supported. This results in a raising of a `PyViCareNotSupportedFeatureError` if the dedicated method is called. This is most likely not a bug, but a limitation of the device itself.

  Tip: You can use Pythons [contextlib.suppress](https://docs.python.org/3/library/contextlib.html#contextlib.suppress) to handle it gracefully.



  - Use `asGazBoiler` for gas heatings
  - Use `asHeatPump` for heat pumps
  - Use `asFuelCell` for fuel cells
  - Use `asPelletsBoiler` for pellets heatings
  - Use `asOilBoiler` for oil heatings
  - Use `asHybridDevice` for gas/heat pump hybrid heatings



  ```python
  import sys
  import logging
  from PyViCare.PyViCare import PyViCare

  client_id = "INSERT CLIENT ID"
  email = "email@domain"
  password = "password"

  vicare = PyViCare()
  vicare.initWithCredentials(email, password, client_id, "token.save")
  device = vicare.devices[0]
  print(device.getModel())
  print("Online" if device.isOnline() else "Offline")

  t = device.asAutoDetectDevice()
  print(t.getDomesticHotWaterConfiguredTemperature())
  print(t.getDomesticHotWaterStorageTemperature())
  print(t.getOutsideTemperature())
  print(t.getRoomTemperature())
  print(t.getBoilerTemperature())
  print(t.setDomesticHotWaterTemperature(59))

  circuit = t.circuits[0] #select heating circuit

  print(circuit.getSupplyTemperature())
  print(circuit.getHeatingCurveShift())
  print(circuit.getHeatingCurveSlope())

  print(circuit.getActiveProgram())
  print(circuit.getPrograms())

  print(circuit.getCurrentDesiredTemperature())
  print(circuit.getDesiredTemperatureForProgram("comfort"))
  print(circuit.getActiveMode())

  print(circuit.getDesiredTemperatureForProgram("comfort"))
  print(circuit.setProgramTemperature("comfort",21))
  print(circuit.activateProgram("comfort"))
  print(circuit.deactivateComfort())

  burner = t.burners[0] #select burner
  print(burner.getActive())

  compressor = t.compressors[0] #select compressor
  print(compressor.getActive())

  ```



  Follow these steps to access the API in Postman:

  1. Create an access token in the `Authorization` tab with type `OAuth 2.0` and following inputs:

     - Token Name: `PyViCare`
     - Grant Type: `Authorization Code (With PKCE)`
     - Callback URL: `vicare://oauth-callback/everest`
     - Authorize using browser: Disabled
     - Auth URL: `https://iam.viessmann.com/idp/v3/authorize`
     - Access Token URL: `https://iam.viessmann.com/idp/v3/token`
     - Client ID: Your personal Client ID created in the developer portal.
     - Client Secret: Blank
     - Code Challenge Method: `SHA-256`
     - Code Veriefier: Blank
     - Scope: `IoT User`
     - State: Blank
     - Client Authentication: `Send client credentials in body`.

     A login popup will open. Enter your ViCare username and password.

  2. Use this URL to access your `installationId`, `gatewaySerial` and `deviceId`:

     `https://api.viessmann.com/iot/v1/equipment/installations?includeGateways=true`

     - `installationId` is `data[0].id`
     - `gatewaySerial` is `data[0].gateways[0].serial`
     - `deviceId` is `data[0].gateways[0].devices[0].id`

  3. Use above data to replace `{installationId}`, `{gatewaySerial}` and `{deviceId}` in this URL to investigate the Viessmann API:

     `https://api.viessmann.com/iot/v1/features/installations/{installationId}/gateways/{gatewaySerial}/devices/{deviceId}/features`



  [Due to latest changes in the Viessmann API](https://www.viessmann-community.com/t5/Konnektivitaet/Q-amp-A-Viessmann-API/td-p/127660) rate limits can be hit. In that case a `PyViCareRateLimitError` is raised. You can read from the error (`limitResetDate`) when the rate limit is reset.



  In order to help ensuring making it easier to create more test cases you can run this code and make a pull request with the new test of your device type added. Your test should be committed into [tests/response](tests/response) and named `<family><model>`.

  The code to run to make this happen is below. This automatically removes "sensitive" information like installation id and serial numbers.
  You can either replace default values or use the `PYVICARE_*` environment variables.

  ```python
  import sys
  import os
  from PyViCare.PyViCare import PyViCare

  client_id = os.getenv("PYVICARE_CLIENT_ID", "INSERT CLIENT_ID")
  email = os.getenv("PYVICARE_EMAIL", "email@domain")
  password = os.getenv("PYVICARE_PASSWORD", "password")

  vicare = PyViCare()
  vicare.initWithCredentials(email, password, client_id, "token.save")

  with open(f"dump.json", mode='w') as output:
     output.write(vicare.devices[0].dump_secure())

  ```


pkgId: efa0cc22e5f6a5eaf4f2534dd79350aaf673eb01db04e7ea413d19c4f65fe361
name: python-Pycodz-help
arch: noarch
version: 2.3
epoch: 0
release: 1
summary: Development documents and examples for Pycodz
url: https://github.com/A-X-1/test-lib
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Pycodz-2.3-1.src.rpm
location_href: Packages/python-Pycodz-help-2.3-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center"> <img src="https://www2.0zz0.com/2024/12/04/20/801153888.png" alt="Pycodz" width="128"> <h1>Pycodz</h1> <b>A library for Python developers.</b> <b> <a href="https://z44o.github.io"> <br> <li> MY </li> </br> </a> </div>

  <br>

  <div align="center"> <a href="https://pypi.org/project/Pycodz/"> <img src="https://img.shields.io/pypi/v/tgram.svg?logo=python&logoColor=%23959DA5&label=pypi&labelColor=%23282f37" alt="PyPI"> </a> <a href="https://t.me/PyQZe"> <img src="https://img.shields.io/badge/Telegram-Channel-blue.svg?logo=telegram" alt="Telegram Channel"> </a> <a href="https://t.me/PyChTz"> <img src="https://img.shields.io/badge/Telegram-Group-blue.svg?logo=telegram" alt="Telegram Group"> </a> <a href="https://t.me/DevZ44d"> <img src="https://img.shields.io/badge/Telegram-Owner-red.svg?logo=telegram" alt="Telegram Owner"> </a> </div>





  ```bash
  pip install Pycodz -U
  ```


  1- __DarkCode__

  - This Function for { ai } , you can use it for ( penetration Teasting , Hacking Tools )
  ```python
  from Pycodz import Darkcode
  requests = input("- Type your requests : ")
  response = DarkCodz(requests)
  print(response)
  ```

  2- __WormGpt__

  - This Function for { ai }, you can use it for ( penetration Teasting, Hacking Tools ) . vs. 2
  ```python
  from Pycodz import WormGpt
  requests = input("- Type your requests : ")
  response = WormGpt(requests)
  print(response)
  ```

  3- __ChatGpt__

  - This Function for { ai }, you can use it for ( usefull tool { ChatGpt } ) . vs. 3
  ```python
  from Pycodz import ChatGpt
  requests = input("- Type your requests : ")
  response = ChatGpt(requests)
  print(response)
  ```
  4- __Whois__

  - This Function for { Get information from web }, you can use it for ( Get Whois { Information } )
  ```python
  from Pycodz import Whois
  requests = input("- Type url : ")
  response = Whois(requests)
  print(response)
  ```

  5- __IP__

  - This Function for { Get IP { Information } }, you can use it for ( Get IP { Information } )
  ```python
  from Pycodz import IP
  requests = input("- Type your url : ")
  response = IP(requests)
  print(response)
  ```

  6- __Programmer_Languages__

  - This Function for { Get Programming_Languages from web } .
  ```python
  from Pycodz import Programmer_Languages
  requests = input("- Type your url : ")
  response = Programmer_Languages(requests)
  print(response)
  ```

  7- __MD5__

  - This Function for { Get MD5_Hash }, you can use it for ( Make MD5_hash )
  ```python
  from Pycodz import MD5
  requests = input("- Type your text : ")
  response = MD5(requests)
  print(response)
  ```

  8- __SHA1__

  - This Function for { Get SHA1_Hash }, you can use it for ( Make SHA1_hash )
  ```python
  from Pycodz import SHA1
  requests = input("- Type your text : ")
  response = SHA1(requests)
  print(response)
  ```
  9- __SHA256__

  - This Function for { Get SHA256_Hash }, you can use it for ( Make SHA256_hash )
   ```python
  from Pycodz import SHA256
  requests = input("- Type your text : ")
  response = SHA256(requests)
  print(response)
  ```

  10- __Base64__

  - This Function for { Get encode } .
  ```python
  from Pycodz import Base64
  requests = input("- Type your text : ")
  response = Base64(requests)
  print(response.__encode__())
  ```

  11- __Base64___

  - This Function for { Get decode } .
  ```python
  from Pycodz import Base64
  requests = input("- Type your text : ")
  response = Base64(requests)
  print(response.__decode__())
  ```

  12- __BlackBox__

  - This Function for { BlackBox-ai }, you can use it for ( BlackBox-ai )
  ```python
  from Pycodz import BlackBox
  requests = input("- Type your Request : ")
  response = BlackBox(requests)
  print(response)
  ```

  13- __Marshel__

  - This Function for { Marshel }, you can use it for ( Marshel ) , Encryption python files ( working in pydroid3 )
   ```python
  from Pycodz import Marshel
  requests = input("- Type your file Name : ")
  response = Marshel(requests)
  print(response)
  ```

  14- __portscan__

  - This function for { portscan ( 2000 Port ) }, you can use it for ( portscan )
  ```python
  from Pycodz import portscan , service_port
  requests = input("- Type your url : ")
  openport = portscan(requests)
  for open_port in openport:
       service = service_port(open_port)
       print(f"- Open Port {open_port}   -   {service}")
  ```

  15- __Masklink__

  - This function for { masklink }, you can use it for ( mask link )
  ```python
  from Pycodz import Masklink
  masked = Masklink("Original-Link","Mask-Link")
  print(masked)
  ```


  16- __Domain__

  - This function for { domain }, you can use it for ( exctact domain site )

  ```python
  from Pycodz import Domain
  requests = input("- Type your url : ")
  domain = Domain(requests)
  print(domain)
  ```

  17- __wifi__

  - This function for { ( you must connect it befor ) wifi }, you can use it for ( get wifi password )

  ```python
  from Pycodz import wifi
  input_wifi = input("- Type name network : ")
  wifi_password = wifi(input_wifi)
  print(wifi_password)
  ```
  18- __Quotes__
  - good Quotes , you can use get Quotes
  ```python
  from Pycodz import Quotes
  object = Quotes()
  get_Quote = object.Quote()
  print(get_Quote)
  ```


       - Linux
       - Windows
       - Termux ( Android )
       - Pydroid3 ( Android )


  - For general questions and help, join our **[Telegram chat](https://t.me/PyChTz)**.
  - Follow updates via the **[Telegram Channel](https://t.me/PyQZe)**.


pkgId: 018fbeccda7dadc13afcf54e4761e26d2b38fc61367f6e936902bd52472d74ee
name: python-PygameXtras-help
arch: noarch
version: 1.3.1
epoch: 0
release: 1
summary: Development documents and examples for PygameXtras
url: https://github.com/marcelm9/PygameXtras.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PygameXtras-1.3.1-1.src.rpm
location_href: Packages/python-PygameXtras-help-1.3.1-1.noarch.rpm
checksum_type: sha256
description:
  PygameXtras is a library designed to make programming with pygame easier. It supplies classes that aim at reducing the time and effort that go into everyday tasks like displaying text, creating buttons, managing entry forms, etc.


  ```python
  import pygame
  import PygameXtras as px

  pygame.init()
  screen = pygame.display.set_mode((500, 600))
  clock = pygame.time.Clock()

  circle_center = (350, 350)
  circle_radius = 50

  mouse_radius = 70
  color = "blue"

  line_y = 260

  buttons = [
      px.Button(
          screen,
          c,
          25,
          (15 + i * 140, 15),
          "topleft",
          fd=(125, 40),
          bw=3,
          br=10,
          hl=True,
          bgc=c,
      )
      for i, c in enumerate(("purple", "green", "blue"))
  ]

  label_touching = px.Label(screen, "not touching", 16, (0, 0), tc="red")
  label_distance = px.Label(screen, "distance: n/a", 30, (25, 75), "topleft", tc=0)

  entry = px.Entry(
      screen,
      "",
      25,
      (15, 135),
      "topleft",
      fd=(200, 40),
      bgc=150,
      bw=3,
      br=10,
      twe="custom color",
      ast=True,
  )

  while True:
      events = pygame.event.get()
      for event in events:
          if event.type == pygame.QUIT:
              pygame.quit()
              exit()

      for button in buttons:
          if button.update(events):
              color = button.backgroundcolor

      entry.update(events)
      if entry.get_state():
          entry.update_colors(bordercolor="blue")
      else:
          entry.update_colors(bordercolor="black")
      if entry.get() != "":
          try:
              color = px.parsers.Color.parse(entry.get())
          except:
              pass

      mouse_pos = pygame.mouse.get_pos()
      mouse_pos = (mouse_pos[0], max(line_y, mouse_pos[1]))
      if px.Collisions.circle_circle(
          mouse_pos, mouse_radius, circle_center, circle_radius
      ):
          label_touching.update_text("touching")
          label_touching.update_colors(textcolor="lime")
      else:
          label_touching.update_text("not touching")
          label_touching.update_colors(textcolor="red")
      label_touching.update_pos(mouse_pos)
      label_distance.update_text(
          f"distance: {max(0, round(px.get_distance(mouse_pos, circle_center) - mouse_radius - circle_radius, 1))} px"
      )

      screen.fill((20, 90, 20))
      pygame.draw.circle(screen, (128, 128, 128), circle_center, circle_radius)
      pygame.draw.circle(screen, color, mouse_pos, mouse_radius)
      pygame.draw.line(
          screen, (0, 0, 0), (0, line_y - mouse_radius), (500, line_y - mouse_radius)
      )
      label_touching.draw()
      label_distance.draw()
      for button in buttons:
          button.draw()
      entry.draw()

      pygame.display.flip()
      clock.tick(120)
  ```


  Labels (any classes inheriting from Label) can be styled using keyword arguments. The tables given below list all positional and keyword arguments and their specific uses. Please note: The types `Color`, `Coordinate`, `PositiveInt`, `PositiveFloat`, `Size2` and `Size4` refer to any values which are successfully digested by their respective parser (found in `PygameXtras.parsers`).


  name | type | info | default
  -|-|-|-
  surface|pygame.Surface, None|the surface which the Label should be drawn to|-
  text|Any|the text displayed on the Label|-
  size|PositiveFloat|the size of the displayed text|-
  xy|Coordinate|the pixel coordinates of the Label|-
  anchor|str|the point within the Label which should be bound to the `xy` coordinate, similar to `pygame.Rect`s positioning system|`"center"`


  The last column, "LBE", shows for which widget (L = Label, B = Button, E = Entry) which keyword is relevant.

  long | short | type | info | default | LBE
  -|-|-|-|-|-
  textcolor|tc|Color|sets the textcolor|`(0,0,0)`|LBE
  backgroundcolor|bgc|Color|sets the backgroundcolor, transparent if set to `None`|`None`|LBE
  antialias|aa|bool|whether antialiasing should be used|`True`|LBE
  font|f|str|font style (to see all built-in fonts, run `PygameXtras.get_fonts()`)|`verdana`|LBE
  x_axis_addition|xad|PositiveInt|adds pixels to the background of the label along the x axis|`0`|LBE
  y_axis_addition|yad|PositiveInt|adds pixels to the background of the label along the y axis|`0`|LBE
  borderwidth|bw|PositiveInt|sets the borderwidth|`0`|LBE
  bordercolor|bc|Color|sets the bordercolor|`(0,0,0)`|LBE
  force_width|fw|PositiveInt|sets the width of the Label to the given size|`None`|LBE
  force_height|fh|PositiveInt|sets the height of the Label to the given size|`None`|LBE
  force_dim|fd|Size2|sets the width and the height of the Label to the given size|`None`|LBE
  borderradius|br|PositiveInt, Size4|sets the borderradius|`1`|LBE
  text_offset|to|Coordinate|offsets the text within the Label by the given amount|`(0,0)`|LBE
  image|img|pygame.Surface|sets the background of the Label to be the image given|`None`|LBE
  info|info|Any|can be used to attach any information to the Label|`None`|LBE
  text_binding|tb|str|binds the text to a location within the Label (similar to `anchor`)|`center`|LBE
  highlight|hl|bool, Color|highlights the Button if the cursor touches it|`None`|BE
  active_area|aA|Size4|limits the Button functionality to an absolute area (any clicks on the button while it is outside of the given area are not registered)|`None`|BE
  bold|bo|bool|sets text styling to bold|`False`|LBE
  italic|it|bool|sets text styling to italic|`False`|LBE
  underline|ul|bool|sets text styling to underline|`False`|LBE
  one_click_manager|ocm|OneClickManager|suppresses clicks if a different Button has already been clicked|`None`|BE
  template|t|dict|injects style keywords from the given template|`None`|LBE
  margin|m|PositiveInt, Size4|adds a margin that decreases the size of the Label without affecting its position |`None`|LBE
  font_file|ff|str|sets the font of the Label to the given font|`None`|LBE


pkgId: 8f8d44f485c447b7b27eba087a63cea3f4e001c95220a52b28052a5a8fbf71cb
name: python-Pysimxrd-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for Pysimxrd
url: https://github.com/Bin-Cao/SimXRD
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Pysimxrd-0.1.0-1.src.rpm
location_href: Packages/python-Pysimxrd-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  Introducing SimXRD, the largest open-source simulation dataset designed for crystallographic informatics, aimed at advancing real-time crystal analysis. It comprises 4,065,346 d-I (lattice plan distance-intensity) powder X-ray diffraction (XRD) patterns alongside corresponding chemical formulas, elemental components, space groups, and crystal systems. These data encompass 119,569 distinct crystal structures and span 33 simulated diffraction conditions, including those mimicking real grain size, internal stress, external temperature variations, instrument drift, and noise. We employ a range of baseline models in this interdisciplinary endeavor to underscore the ML challenges and their evaluation metrics.

  SimXRD is freely accessible after filling out the following basic information. For any inconvenience, please feel free to contact Mr. Cao Bin at: bcao686@connect.hkust-gz.edu.cn


pkgId: 61182d93dcb1ce1a498599a88fedf41fb4f8890edcb1bc2ebe65b29b06dfa46b
name: python-Pytdbot-help
arch: noarch
version: 0.8.8
epoch: 0
release: 1
summary: Development documents and examples for Pytdbot
url: https://github.com/pytdbot/client
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Pytdbot-0.8.8-1.src.rpm
location_href: Packages/python-Pytdbot-help-0.8.8-1.noarch.rpm
checksum_type: sha256
description:
  Pytdbot (Python TDLib) is an asynchronous [**TDLib**](https://github.com/tdlib/td) wrapper for **Telegram** users/bots written in **Python**.


  - Easy, **Fast** and **Powerful**
  - Fully **asynchronous**
  - **Decorator** based update handler
  - **Bound** methods
  - Supports **userbots**, **Plugins**, [**Filters**](https://github.com/pytdbot/client/blob/ad33d05d3e48bc8842b3986613ad2d99480a1fa8/pytdbot/filters.py#L23), [**TDLib**](https://github.com/tdlib/td) functions and much more.




  - Python 3.9+
  - Telegram [API key](https://my.telegram.org/apps)
  - [tdjson](https://github.com/tdlib/td#building)
  - [deepdiff](https://github.com/seperman/deepdiff)


  > For better performance, it's recommended to install [orjson](https://github.com/ijl/orjson#install) or [ujson](https://github.com/ultrajson/ultrajson#ultrajson).

  You can install Pytdbot using pip:
  ```bash
  pip install pytdbot
  ```
  To install the development version from Github, use the following command:
  ```bash
  pip install git+https://github.com/pytdbot/client.git
  ```


  Basic example:
  ```python

  from pytdbot import Client, utils
  from pytdbot.types import LogStreamFile, Update

  client = Client(
      api_id=0,
      api_hash="API_HASH",
      database_encryption_key="1234echobot$",
      token="1088394097:AAQX2DnWiw4ihwiJUhIHOGog8gGOI",  # Your bot token or phone number if you want to login as user
      files_directory="BotDB",  # Path where to store TDLib files
      lib_path="/path/to/libtdjson.so", # Path to TDjson shared library
      td_log=LogStreamFile("tdlib.log"),  # Set TDLib log file path
      td_verbosity=2,  # TDLib verbosity level
  )


  @client.on_updateNewMessage()
  async def print_message(c: Client, message: Update):
      print(message)


  @client.on_updateNewMessage()
  async def simple_message(c: Client, message: Update):
      if message.is_private:
          await message.reply_text('Hi! i am simple bot')

      if message.is_self and message.text: # Works only for userbots.
          if message.text == "!id":
              await message.edit_text(
                  "\\- Current chat ID: {}\n\\- {} ID: {}".format(
                      utils.code(str(message.chat_id)),
                      utils.bold(c.me["first_name"]),
                      utils.code(str(message.from_id)),
                  ),
                  parse_mode="markdownv2",
              )




  client.run()

  ```
  For more examples, check the [examples](https://github.com/pytdbot/client/tree/main/examples) folder.


  - You for viewing or using this project.

  - [@levlam](https://github.com/levlam) for maintaining [TDLib](https://github.com/tdlib/td) and for the help to create [Pytdbot](https://github.com/pytdbot/client).


  MIT [License](https://github.com/pytdbot/client/blob/main/LICENSE)


pkgId: cada16fb0dc0271b6e68a0c9f337f63f24e50b1789e54490f707fc3c9cbc1739
name: python-Pytolith-help
arch: noarch
version: 0.0.7
epoch: 0
release: 1
summary: Development documents and examples for Pytolith
url: https://github.com/num0005/Pytolith
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Pytolith-0.0.7-1.src.rpm
location_href: Packages/python-Pytolith-help-0.0.7-1.noarch.rpm
checksum_type: sha256
description:
  A simple python library for reading (and perhaps writing in the future) Halo 2 tag files. Allows for tags to be introspected on any platform without the hassle of using the official tools.

  SemVer may eventually be used but for now the API is unstable and subject to change at any time. Tag layouts are [defined in XML](https://github.com/num0005/Halo2TagLayouts) in a separate repository and are compiled into a pickled format during package installation. The package license does not cover this layout metadata.



  ```python
  from Pytolith import TagSystem
  import os


  system = TagSystem()

  MY_H2EK_TAGS_FOLDER = r"T:\SteamLibrary\steamapps\common\H2EK\tags"
  BRUTE_TAG_PATH = r"objects\characters\brute\brute.biped"

  path = os.path.join(MY_H2EK_TAGS_FOLDER, BRUTE_TAG_PATH)


  tag1 = system.load_tag_from_path(path)

  print(tag1.fields.feign_death_chance)
  ```

  If you want to edit the XML definitions first clone `https://github.com/num0005/Halo2TagLayouts` into a local path:

  ```shell
  T:\> git clone https://github.com/num0005/Halo2TagLayouts
  Cloning into 'Halo2TagLayouts'...
  remote: Enumerating objects: 156, done.
  remote: Counting objects: 100% (156/156), done.
  remote: Compressing objects: 100% (96/96), done.
  remote: Total 156 (delta 60), reused 156 (delta 60), pack-reused 0 (from 0)
  Receiving objects: 100% (156/156), 384.26 KiB | 11.64 MiB/s, done.
  Resolving deltas: 100% (60/60), done.
  ```

  And then set the custom definitions when constructing the `TagSystem` object:

  ```python
  from Pytolith.Definitions import Definitions
  from Pytolith import TagSystem

  custom_defintions = Definitions()
  custom_defintions.load_from_xml(r"T:\Halo2TagLayouts")

  system = TagSystem(tag_definitions=custom_defintions)
  ```

  You will now be using the tag definitions from `T:\Halo2TagLayouts` instead of the ones packaged with the library.



  Install the package using `pip` is the recommended way to use it, but if you are unable to to that or want to avoid installing it during development you can load the package directly. For instance `setup.py` does it like so:

  ```python
  root_directory = pathlib.Path(os.path.abspath(__file__)).parent
  sys.path.append(str(root_directory/"src"))
  import Pytolith
  ```

  This depends on the tag definitions being located in the `Data` folder. Make sure you initialize git submodules if you are doing this.




  Using PyPy is recommended as the tracing compiler provides a ~2x speed up on tag loading.

  Installed packages include autogenerated tag readers which provide a minor (~10%) speed-up when using CPython. These can only be used if you use the tag definitions packaged with the library. See `code_generator.py` and `setup.py` for details on how the "fast loaders" are generated.

  Installed packages also use `pickle`'d tag definitions, this provides a modest speed-up on first tag load.


pkgId: c5386503fbcfb9691329005ec1fcf32df1f196228b9049e5f11b32abad83536b
name: python-PytorchWildlife-help
arch: noarch
version: 1.1.1
epoch: 0
release: 1
summary: Development documents and examples for PytorchWildlife
url: https://github.com/microsoft/CameraTraps/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PytorchWildlife-1.1.1-1.src.rpm
location_href: Packages/python-PytorchWildlife-help-1.1.1-1.noarch.rpm
checksum_type: sha256
description:
  ![image](https://microsoft.github.io/CameraTraps/assets/Pytorch_Banner_transparentbk.png)

  <div align="center">
  <font size="6"> A Collaborative Deep Learning Framework for Conservation </font>
  <br>
  <hr>
  <a href="https://pypi.org/project/PytorchWildlife"><img src="https://img.shields.io/pypi/v/PytorchWildlife?color=limegreen" /></a>
  <a href="https://pypi.org/project/PytorchWildlife"><img src="https://static.pepy.tech/badge/pytorchwildlife" /></a>
  <a href="https://pypi.org/project/PytorchWildlife"><img src="https://img.shields.io/pypi/pyversions/PytorchWildlife" /></a>
  <a href="https://huggingface.co/spaces/ai-for-good-lab/pytorch-wildlife"><img src="https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Demo-blue" /></a>
  <a href="https://colab.research.google.com/drive/1rjqHrTMzEHkMualr4vB55dQWCsCKMNXi?usp=sharing"><img src="https://img.shields.io/badge/Colab-Demo-blue?logo=GoogleColab" /></a>
  <!-- <a href="https://colab.research.google.com/drive/16-OjFVQ6nopuP-gfqofYBBY00oIgbcr1?usp=sharing"><img src="https://img.shields.io/badge/Colab-Video detection-blue?logo=GoogleColab" /></a> -->
  <a href="https://cameratraps.readthedocs.io/en/latest/"><img src="https://img.shields.io/badge/read-docs-yellow?logo=ReadtheDocs" /></a>
  <a href="https://github.com/microsoft/CameraTraps/blob/main/LICENSE"><img src="https://img.shields.io/pypi/l/PytorchWildlife" /></a>
  <a href="https://discord.gg/TeEVxzaYtm"><img src="https://img.shields.io/badge/any_text-Join_us!-blue?logo=discord&label=Discord" /></a>
  <br><br>
  </div>



  At the core of our mission is the desire to create a harmonious space where conservation scientists from all over the globe can unite. Where they're able to share, grow, use datasets and deep learning architectures for wildlife conservation.
  We've been inspired by the potential and capabilities of Megadetector, and we deeply value its contributions to the community. As we forge ahead with Pytorch-Wildlife, under which Megadetector now resides, please know that we remain committed to supporting, maintaining, and developing Megadetector, ensuring its continued relevance, expansion, and utility.

  Pytorch-Wildlife is pip installable:
  ```
  pip install PytorchWildlife
  ```

  To use the newest version of MegaDetector with all the existing functionalities, you can use our [Hugging Face interface](https://huggingface.co/spaces/ai-for-good-lab/pytorch-wildlife) or simply load the model with **Pytorch-Wildlife**. The weights will be automatically downloaded:
  ```python
  from PytorchWildlife.models import detection as pw_detection
  detection_model = pw_detection.MegaDetectorV6()
  ```

  For those interested in accessing the previous MegaDetector repository, which utilizes the same `MegaDetectorV5` model weights and was primarily developed by Dan Morris during his time at Microsoft, please visit the [archive](https://github.com/microsoft/CameraTraps/blob/main/archive) directory, or you can visit this [forked repository](https://github.com/agentmorris/MegaDetector/tree/main) that Dan Morris is actively maintaining.

  >[!TIP]
  >If you have any questions regarding MegaDetector and Pytorch-Wildlife, please [email us](zhongqimiao@microsoft.com) or join us in our discord channel: [![](https://img.shields.io/badge/any_text-Join_us!-blue?logo=discord&label=PytorchWildife)](https://discord.gg/TeEVxzaYtm)





  - MegaDetectorV6 is finally out! Please refer to our [next section](#racing_cardashdash-megadetectorv6-smaller-better-and-faster) and our [release notes](https://github.com/microsoft/CameraTraps/releases/tag/pw_v1.1.0) for more details!
  - We have incorporated a point-based overhead animal detection model into our model zoo called [HerdNet (Delplanque et al. 2022)](https://www.sciencedirect.com/science/article/pii/S092427162300031X?via%3Dihub). Two model weights are incorporated in this release, `HerdNet-general` (their default weights) and `HerdNet-ennedi` (their model trained on Ennedi 2019 datasets). More details can be found [here](PytorchWildlife/models/detection/herdnet/Herdnet.md) and in their original [repo](https://github.com/Alexandre-Delplanque/HerdNet). This is the first third-party model in Pytorch-Wildlife and the foundation of our expansion to overhead/aerial animal detection and classification. Please see our [HerdNet demo](demo/image_detection_demo_herdnet.ipynb) on how to use it!
  - You can now load custom weights you fine-tuned on your own datasets using the [finetuning module](PW_FT_classification) directly in the Pytorch-Wildlife pipeline! Please see the [demo](demo/custom_weight_loading_v6.ipynb) on how to do it. You can also load it in our Gradio app!
  - You can now automatically separate your image detections into folders based on detection results! Please see our [folder separation demo](demo/image_separation_demo_v6.ipynb) on how to do it. You can also test it in our Gradio demo!
  - We have also simplified the batch detection pipeline. Now we do not need to define pytorch datasets and dataloaders specifically. Please make sure to change your code and check our [release notes](https://github.com/microsoft/CameraTraps/releases/tag/pw_v1.1.0) and our [new demo](demo/image_demo.py#58) for more details.


  <details>
  <summary><font size="3">👉 Click for more updates</font></summary>
    <li> Issues [#523](https://github.com/microsoft/CameraTraps/issues/523), [#524](https://github.com/microsoft/CameraTraps/issues/524) and [#526](https://github.com/microsoft/CameraTraps/issues/526) have been solved!
    <li> PyTorchWildlife is now compatible with Supervision 0.23+ and Python 3.10+!
    <li> CUDA 12.x compatibility. <br>
  </details>



  After a few months of public beta testing, we are finally ready to officially release our 6th version of MegaDetector, MegaDetectorV6! In the next generation of MegaDetector, we are focusing on computational efficiency, performance, mordernizing of model architectures, and licensing. We have trained multiple new models using different model architectures, including Yolo-v9, Yolo-v11, and RT-Detr for maximum user flexibility. We have a [rolling release schedule](#mag-model-zoo-and-release-schedules) for different versions of MegaDetectorV6, and in the first step, we are releasing the compact version of MegaDetectorV6 with Yolo-v9 (MDv6-ultralytics-yolov9-compact, MDv6-c in short). From now on, we encourage our users to use MegaDetectorV6 as their default animal detection model.

  This MDv6-c model is optimized for performance and low-budget devices. It has only ***one-sixth (SMALLER)*** of the parameters of the previous MegaDetectorV5 and exhibits ***12% higher recall (BETTER)*** on animal detection in our validation datasets. In other words, MDv6-c has significantly fewer false negatives when detecting animals, making it a more robust animal detection model than MegaDetectorV5. Furthermore, one of our testers reported that the speed of MDv6-c is at least ***5 times FASTER*** than MegaDetectorV5 on their datasets.

  |Models|Parameters|Precision|Recall|
  |---|---|---|---|
  |MegaDetectorV5|121M|0.96|0.73|
  |MegaDetectroV6-c|22M|0.92|0.85|

  Learn how to use MegaDetectorV6 in our [image demo](demo/image_detection_demo_v6.ipynb) and [video demo](demo/video_detection_demo_v6.ipynb).



  The **Pytorch-Wildlife** package is under MIT, however some of the models in the model zoo are not. For example, MegaDetectorV5, which is trained using the Ultralytics package, is under AGPL-3.0, and is not for closed-source comercial uses.
  > [!IMPORTANT]
  > THIS IS TRUE TO ALL EXISTING MEGADETECTORV5 MODELS IN ALL EXISTING FORKS THAT ARE TRAINED USING YOLOV5, AN ULTRALYTICS-DEVELOPED MODEL.

  We want to make Pytorch-Wildlife a platform where different models with different licenses can be hosted and want to enable different usecases. To reduce user confusions, in our [model zoo](#mag-model-zoo) section, we list all existing and planed future models in our model zoo, their corresponding license, and release schedules.

  In addition, since the **Pytorch-Wildlife** package is under MIT, all the utility functions, including data pre-/post-processing functions and model fine-tuning functions in this packages are under MIT as well.




  |Models|Licence|Release|
  |---|---|---|
  |MegaDetectorV5|AGPL-3.0|Released|
  |MegaDetectroV6-Ultralytics-YoloV9-Compact|AGPL-3.0|Released|
  |HerdNet-general|CC BY-NC-SA-4.0|Released|
  |HerdNet-ennedi|CC BY-NC-SA-4.0|Released|
  |MegaDetectroV6-Ultralytics-YoloV9-Extra|AGPL-3.0|November 2024|
  |MegaDetectroV6-Ultralytics-YoloV10-Compact (even smaller and no NMS)|AGPL-3.0|November 2024|
  |MegaDetectroV6-Ultralytics-YoloV10-Extra (extra large model and no NMS)|AGPL-3.0|November 2024|
  |MegaDetectroV6-MIT-YoloV9-Compact|MIT|December 2024|
  |MegaDetectroV6-MIT-YoloV9-Extra|MIT|December 2024|
  |MegaDetectroV6-Ultralytics-YoloV11-Compact (better performance)|AGPL-3.0|December 2024|
  |MegaDetectroV6-Ultralytics-YoloV11-Extra (better performance)|AGPL-3.0|December 2024|
  |MegaDetectroV6-Apache-RTDetr-Compact|Apache|January 2025|
  |MegaDetectroV6-Apache-RTDetr-Extra|Apache|January 2025|


  |Models|Licence|Release|
  |---|---|---|
  |AI4G-Oppossum|MIT|Released|
  |AI4G-Amazon|MIT|Released|
  |AI4G-Serengeti|MIT|Released|




  **PyTorch-Wildlife** is a platform to create, modify, and share powerful AI conservation models. These models can be used for a variety of applications, including camera trap images, overhead images, underwater images, or bioacoustics. Your engagement with our work is greatly appreciated, and we eagerly await any feedback you may have.


  The **Pytorch-Wildlife** library allows users to directly load the `MegaDetector` model weights for animal detection. We've fully refactored our codebase, prioritizing ease of use in model deployment and expansion. In addition to `MegaDetector`, **Pytorch-Wildlife** also accommodates a range of classification weights, such as those derived from the Amazon Rainforest dataset and the Opossum classification dataset. Explore the codebase and functionalities of **Pytorch-Wildlife** through our interactive [HuggingFace web app](https://huggingface.co/spaces/AndresHdzC/pytorch-wildlife) or local [demos and notebooks](https://github.com/microsoft/CameraTraps/tree/main/demo), designed to showcase the practical applications of our enhancements at [PyTorchWildlife](https://github.com/microsoft/CameraTraps/blob/main/INSTALLATION.md). You can find more information in our [documentation](https://cameratraps.readthedocs.io/en/latest/).

  👇 Here is a brief example on how to perform detection and classification on a single image using `PyTorch-wildlife`
  ```python
  import numpy as np
  from PytorchWildlife.models import detection as pw_detection
  from PytorchWildlife.models import classification as pw_classification

  img = np.random.randn(3, 1280, 1280)


  detection_model = pw_detection.MegaDetectorV6() # Model weights are automatically downloaded.
  detection_result = detection_model.single_image_detection(img)


  classification_model = pw_classification.AI4GAmazonRainforest() # Model weights are automatically downloaded.
  classification_results = classification_model.single_image_classification(img)
  ```


  ```
  pip install PytorchWildlife
  ```
  Please refer to our [installation guide](https://github.com/microsoft/CameraTraps/blob/main/INSTALLATION.md) for more installation information.



  If you want to directly try **Pytorch-Wildlife** with the AI models available, including `MegaDetector`, you can use our [**Gradio** interface](https://github.com/microsoft/CameraTraps/tree/main/demo). This interface allows users to directly load the `MegaDetector` model weights for animal detection. In addition, **Pytorch-Wildlife** also has two classification models in our initial version. One is trained from an Amazon Rainforest camera trap dataset and the other from a Galapagos opossum classification dataset (more details of these datasets will be published soon). To start, please follow the [installation instructions](https://github.com/microsoft/CameraTraps/blob/main/INSTALLATION.md) on how to run the Gradio interface! We also provide multiple [**Jupyter** notebooks](https://github.com/microsoft/CameraTraps/tree/main/demo) for demonstration.

  ![image](https://microsoft.github.io/CameraTraps/assets/gradio_UI.png)



     What are the core components of Pytorch-Wildlife?
  ![Pytorch-core-diagram](https://microsoft.github.io/CameraTraps/assets/Pytorch_Wildlife_core_figure.jpg)



    Pytorch-Wildlife integrates **four pivotal elements:**

  ▪ Machine Learning Models<br>
  ▪ Pre-trained Weights<br>
  ▪ Datasets<br>
  ▪ Utilities<br>


    In the provided graph, boxes outlined in red represent elements that will be added and remained fixed, while those in blue will be part of our development.



    We're kickstarting with YOLO as our first available model, complemented by pre-trained weights from `MegaDetector`. We have `MegaDetectorV5`, which is the same `MegaDetector v5` model from the previous repository, and many different versions of `MegaDetectorV6` for different usecases.



    As we move forward, our platform will welcome new models and pre-trained weights for camera traps and bioacoustic analysis. We're excited to host contributions from global researchers through a dedicated submission platform.



    Pytorch-Wildlife will also incorporate the vast datasets hosted on LILA, making it a treasure trove for conservation research.



    Our set of utilities spans from visualization tools to task-specific utilities, many inherited from Megadetector.



    While we provide a foundational user interface, our platform is designed to inspire. We encourage researchers to craft and share their unique interfaces, and we'll list both existing and new UIs from other collaborators for the community's benefit.


  Let's shape the future of wildlife research, together! 🙌




  <img src="https://microsoft.github.io/CameraTraps/assets/animal_det_1.JPG" alt="animal_det_1" width="400"/><br>
  *Credits to Universidad de los Andes, Colombia.*


  <img src="https://microsoft.github.io/CameraTraps/assets/animal_clas_1.png" alt="animal_clas_1" width="500"/><br>
  *Credits to Universidad de los Andes, Colombia.*


  <img src="https://microsoft.github.io/CameraTraps/assets/opossum_det.png" alt="opossum_det" width="500"/><br>
  *Credits to the Agency for Regulation and Control of Biosecurity and Quarantine for Galápagos (ABG), Ecuador.*


  - [ ] A detection model fine-tuning module to fine-tune your own detection model for Pytorch-Wildlife.
  - [ ] Direct LILA connection for more training/validation data.
  - [ ] More pretrained detection and classification models to expand the current model zoo.

  To check the full version of the roadmap with completed tasks and long term goals, please click [here!](roadmaps.md).


  We are thrilled to announce our collaboration with [EcoAssist](https://addaxdatascience.com/ecoassist/#spp-models)---a powerful user interface software that enables users to directly load models from the PyTorch-Wildlife model zoo for image analysis on local computers. With EcoAssist, you can now utilize MegaDetectorV5 and the classification models---AI4GAmazonRainforest and AI4GOpossum---for automatic animal detection and identification, alongside a comprehensive suite of pre- and post-processing tools. This partnership aims to enhance the overall user experience with PyTorch-Wildlife models for a general audience. We will work closely to bring more features together for more efficient and effective wildlife analysis in the future.



  We have recently published a [summary paper on Pytorch-Wildlife](https://arxiv.org/abs/2405.12930). The paper has been accepted as an oral presentation at the [CV4Animals workshop](https://www.cv4animals.com/) at this CVPR 2024. Please feel free to cite us!

  ```
  @misc{hernandez2024pytorchwildlife,
        title={Pytorch-Wildlife: A Collaborative Deep Learning Framework for Conservation},
        author={Andres Hernandez and Zhongqi Miao and Luisa Vargas and Sara Beery and Rahul Dodhia and Juan Lavista},
        year={2024},
        eprint={2405.12930},
        archivePrefix={arXiv},
  }
  ```

  Also, don't forget to cite our original paper for MegaDetector:

  ```
  @misc{beery2019efficient,
        title={Efficient Pipeline for Camera Trap Image Review},
        author={Sara Beery and Dan Morris and Siyu Yang},
        year={2019}
        eprint={1907.06772},
        archivePrefix={arXiv},
  }
  ```


  This project is open to your ideas and contributions. If you want to submit a pull request, we'll have some guidelines available soon.

  We have adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [us](zhongqimiao@microsoft.com) with any additional questions or comments.


  This repository is licensed with the [MIT license](https://github.com/Microsoft/dotnet/blob/main/LICENSE).




  The extensive collaborative efforts of Megadetector have genuinely inspired us, and we deeply value its significant contributions to the community. As we continue to advance with Pytorch-Wildlife, our commitment to delivering technical support to our existing partners on MegaDetector remains the same.

  Here we list a few of the organizations that have used MegaDetector. We're only listing organizations who have given us permission to refer to them here or have posted publicly about their use of MegaDetector.

  <details>
  <summary><font size="3">👉 Full list of organizations</font></summary>

  (Newly Added) [TerrOïko](https://www.terroiko.fr/) ([OCAPI platform](https://www.terroiko.fr/ocapi))

  [Arizona Department of Environmental Quality](http://azdeq.gov/)

  [Blackbird Environmental](https://blackbirdenv.com/)

  [Camelot](https://camelotproject.org/)

  [Canadian Parks and Wilderness Society (CPAWS) Northern Alberta Chapter](https://cpawsnab.org/)

  [Conservation X Labs](https://conservationxlabs.com/)

  [Czech University of Life Sciences Prague](https://www.czu.cz/en)

  [EcoLogic Consultants Ltd.](https://www.consult-ecologic.com/)

  [Estación Biológica de Doñana](http://www.ebd.csic.es/inicio)

  [Idaho Department of Fish and Game](https://idfg.idaho.gov/)

  [Island Conservation](https://www.islandconservation.org/)

  [Myall Lakes Dingo Project](https://carnivorecoexistence.info/myall-lakes-dingo-project/)

  [Point No Point Treaty Council](https://pnptc.org/)

  [Ramat Hanadiv Nature Park](https://www.ramat-hanadiv.org.il/en/)

  [SPEA (Portuguese Society for the Study of Birds)](https://spea.pt/en/)

  [Synthetaic](https://www.synthetaic.com/)

  [Taronga Conservation Society](https://taronga.org.au/)

  [The Nature Conservancy in Wyoming](https://www.nature.org/en-us/about-us/where-we-work/united-states/wyoming/)

  [TrapTagger](https://wildeyeconservation.org/trap-tagger-about/)

  [Upper Yellowstone Watershed Group](https://www.upperyellowstone.org/)

  [Applied Conservation Macro Ecology Lab](http://www.acmelab.ca/), University of Victoria

  [Banff National Park Resource Conservation](https://www.pc.gc.ca/en/pn-np/ab/banff/nature/conservation), Parks Canada(https://www.pc.gc.ca/en/pn-np/ab/banff/nature/conservation)

  [Blumstein Lab](https://blumsteinlab.eeb.ucla.edu/), UCLA

  [Borderlands Research Institute](https://bri.sulross.edu/), Sul Ross State University

  [Capitol Reef National Park](https://www.nps.gov/care/index.htm) / Utah Valley University

  [Center for Biodiversity and Conservation](https://www.amnh.org/research/center-for-biodiversity-conservation), American Museum of Natural History

  [Centre for Ecosystem Science](https://www.unsw.edu.au/research/), UNSW Sydney

  [Cross-Cultural Ecology Lab](https://crossculturalecology.net/), Macquarie University

  [DC Cat Count](https://hub.dccatcount.org/), led by the Humane Rescue Alliance

  [Department of Fish and Wildlife Sciences](https://www.uidaho.edu/cnr/departments/fish-and-wildlife-sciences), University of Idaho

  [Department of Wildlife Ecology and Conservation](https://wec.ifas.ufl.edu/), University of Florida

  [Ecology and Conservation of Amazonian Vertebrates Research Group](https://www.researchgate.net/lab/Fernanda-Michalski-Lab-4), Federal University of Amapá

  [Gola Forest Programma](https://www.rspb.org.uk/our-work/conservation/projects/scientific-support-for-the-gola-forest-programme/), Royal Society for the Protection of Birds (RSPB)

  [Graeme Shannon's Research Group](https://wildliferesearch.co.uk/group-1), Bangor University

  [Hamaarag](https://hamaarag.org.il/), The Steinhardt Museum of Natural History, Tel Aviv University

  [Institut des Science de la Forêt Tempérée (ISFORT)](https://isfort.uqo.ca/), Université du Québec en Outaouais

  [Lab of Dr. Bilal Habib](https://bhlab.in/about), the Wildlife Institute of India

  [Mammal Spatial Ecology and Conservation Lab](https://labs.wsu.edu/dthornton/), Washington State University

  [McLoughlin Lab in Population Ecology](http://mcloughlinlab.ca/lab/), University of Saskatchewan

  [National Wildlife Refuge System, Southwest Region](https://www.fws.gov/about/region/southwest), U.S. Fish & Wildlife Service

  [Northern Great Plains Program](https://nationalzoo.si.edu/news/restoring-americas-prairie), Smithsonian

  [Quantitative Ecology Lab](https://depts.washington.edu/sefsqel/), University of Washington

  [Santa Monica Mountains Recreation Area](https://www.nps.gov/samo/index.htm), National Park Service

  [Seattle Urban Carnivore Project](https://www.zoo.org/seattlecarnivores), Woodland Park Zoo

  [Serra dos Órgãos National Park](https://www.icmbio.gov.br/parnaserradosorgaos/), ICMBio

  [Snapshot USA](https://emammal.si.edu/snapshot-usa), Smithsonian

  [Wildlife Coexistence Lab](https://wildlife.forestry.ubc.ca/), University of British Columbia

  [Wildlife Research](https://www.dfw.state.or.us/wildlife/research/index.asp), Oregon Department of Fish and Wildlife

  [Wildlife Division](https://www.michigan.gov/dnr/about/contact/wildlife), Michigan Department of Natural Resources

  Department of Ecology, TU Berlin

  Ghost Cat Analytics

  Protected Areas Unit, Canadian Wildlife Service

  [School of Natural Sciences](https://www.utas.edu.au/natural-sciences), University of Tasmania [(story)](https://www.utas.edu.au/about/news-and-stories/articles/2022/1204-innovative-camera-network-keeps-close-eye-on-tassie-wildlife)

  [Kenai National Wildlife Refuge](https://www.fws.gov/refuge/kenai), U.S. Fish & Wildlife Service [(story)](https://www.peninsulaclarion.com/sports/refuge-notebook-new-technology-increases-efficiency-of-refuge-cameras/)

  [Australian Wildlife Conservancy](https://www.australianwildlife.org/) [(blog](https://www.australianwildlife.org/cutting-edge-technology-delivering-efficiency-gains-in-conservation/), [blog)](https://www.australianwildlife.org/efficiency-gains-at-the-cutting-edge-of-technology/)

  [Felidae Conservation Fund](https://felidaefund.org/) [(WildePod platform)](https://wildepod.org/) [(blog post)](https://abhaykashyap.com/blog/ai-powered-camera-trap-image-annotation-system/)

  [Alberta Biodiversity Monitoring Institute (ABMI)](https://www.abmi.ca/home.html) [(WildTrax platform)](https://www.wildtrax.ca/) [(blog post)](https://wildcams.ca/blog/the-abmi-visits-the-zoo/)

  [Shan Shui Conservation Center](http://en.shanshui.org/) [(blog post)](https://mp.weixin.qq.com/s/iOIQF3ckj0-rEG4yJgerYw?fbclid=IwAR0alwiWbe3udIcFvqqwm7y5qgr9hZpjr871FZIa-ErGUukZ7yJ3ZhgCevs) [(translated blog post)](https://mp-weixin-qq-com.translate.goog/s/iOIQF3ckj0-rEG4yJgerYw?fbclid=IwAR0alwiWbe3udIcFvqqwm7y5qgr9hZpjr871FZIa-ErGUukZ7yJ3ZhgCevs&_x_tr_sl=auto&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp)

  [Irvine Ranch Conservancy](http://www.irconservancy.org/) [(story)](https://www.ocregister.com/2022/03/30/ai-software-is-helping-researchers-focus-on-learning-about-ocs-wild-animals/)

  [Wildlife Protection Solutions](https://wildlifeprotectionsolutions.org/) [(story](https://customers.microsoft.com/en-us/story/1384184517929343083-wildlife-protection-solutions-nonprofit-ai-for-earth), [story)](https://www.enterpriseai.news/2023/02/20/ai-helps-wildlife-protection-solutions-safeguard-endangered-species/)

  [Road Ecology Center](https://roadecology.ucdavis.edu/), University of California, Davis [(Wildlife Observer Network platform)](https://wildlifeobserver.net/)

  [The Nature Conservancy in California](https://www.nature.org/en-us/about-us/where-we-work/united-states/california/) [(Animl platform)](https://github.com/tnc-ca-geo/animl-frontend)

  [San Diego Zoo Wildlife Alliance](https://science.sandiegozoo.org/) [(Animl R package)](https://github.com/conservationtechlab/animl)

  </details><br>


  >[!IMPORTANT]
  >If you would like to be added to this list or have any questions regarding MegaDetector and Pytorch-Wildlife, please [email us](zhongqimiao@microsoft.com) or join us in our Discord channel: [![](https://img.shields.io/badge/any_text-Join_us!-blue?logo=discord&label=PytorchWildife)](https://discord.gg/TeEVxzaYtm)


pkgId: 632f798e00f14e2da2e61d0f10c31bcdcb375bb28dc650b2de64a4aa07f345dd
name: python-QEasyWidgets-help
arch: noarch
version: 0.6.2
epoch: 0
release: 1
summary: Development documents and examples for QEasyWidgets
url: https://github.com/Spr-Aachen/QEasyWidgets
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-QEasyWidgets-0.6.2-1.src.rpm
location_href: Packages/python-QEasyWidgets-help-0.6.2-1.noarch.rpm
checksum_type: sha256
description:
  <div align = "center">



  [![Releases](https://img.shields.io/github/v/release/Spr-Aachen/QEasyWidgets?color=green&label=Release&logo=Github&logoColor=white&style=for-the-badge)](https://github.com/Spr-Aachen/QEasyWidgets/releases/latest)&nbsp;

  </div>






  A simple widget library based on PySide6, which is currently used to serve for [Easy Voice Toolkit](https://github.com/Spr-Aachen/Easy-Voice-Toolkit) and [LLM-PromptMaster](https://github.com/Spr-Aachen/LLM-PromptMaster).

  Currently this project supports Windows&Linux system.






  ```shell
  pip install QEasyWidgets -i https://pypi.org/simple/
  ```



  [Microsoft WinUI-Gallery](https://github.com/microsoft/WinUI-Gallery)


pkgId: facebf46042cce61c2618a5a455c6f3b44dbf48eff6b1da18e6eb04c26ddcbec
name: python-QuantumIntelligence-help
arch: noarch
version: 0.0.13
epoch: 0
release: 1
summary: Development documents and examples for QuantumIntelligence
url: https://pypi.org/project/QuantumIntelligence/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-QuantumIntelligence-0.0.13-1.src.rpm
location_href: Packages/python-QuantumIntelligence-help-0.0.13-1.noarch.rpm
checksum_type: sha256
description:
  This is the python code to develop quantum intelligence. But for now it is just an efficient quantum simulator based on Pytorch.



  `pip install QuantumIntelligence`


      Copyright (C) <2022>  <Zheng-Zhi Sun>

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

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

      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <https://www.gnu.org/licenses/>.


pkgId: 18dd7811e0ffc2462e71bcc624bbb6de1e11cd99b006c8c486e38364ca3a81c1
name: python-QuantumRingsLib
arch: noarch
version: 0.9.13
epoch: 0
release: 1
summary: A Quantum Development Library
url: https://www.quantumrings.com/docs
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-QuantumRingsLib-0.9.13-1.src.rpm
location_href: Packages/python-QuantumRingsLib-0.9.13-1.noarch.rpm
checksum_type: sha256
description:
  A system with a configuration better than the minimum requirements is advised.
  Lower configurations may affect the number of qubits that can be supported and
  may perform poorly.
  -  Operating systems supported:
     -  Windows 11 Pro
     -  Debian GNU/Linux 12 (bookworm)
     -  OpenSUSE Tumbleweed - Version 20240415
     -  Oracle Linux 9.3
     -  Ubuntu 22.04.4 LTS
     -  macOS Sequoia
  -  64-bit Intel i9 x86 CPU (14 cores 20 logical processors recommended) on Windows or Linux platforms
  -  x86_64 or ARM_64 (that is, Intel or Apple Silicon CPUs) on Apple PCs
  -  32 GB Installed physical memory
  -  18 GB Available physical memory
  -  64-bit Python version 3.11 on Windows
  -  Python 3.6, 3.10, 3.11, and 3.12 on various Linux versions

rpm_license:
  ==================== EVALUATION AGREEMENT ====================  **IMPORTANT:** PLEASE READ THIS EVALUATION AGREEMENT ("**AGREEMENT**") BEFORE CLICKING THE "ACCEPT" BUTTON, AND/OR USING THE QUANTUM RINGS, INC. (**"QUANTUM"**) PRODUCT THAT ACCOMPANIES OR IS PROVIDED IN CONNECTION WITH THIS AGREEMENT. BY CLICKING THE "ACCEPT" BUTTON, AND/OR USING THE SERVICES IN ANY WAY, YOU AND THE ENTITY THAT YOU REPRESENT ("**EVALUATOR**") IS UNCONDITIONALLY CONSENTING TO BE BOUND BY AND IS BECOMING A PARTY TO THIS AGREEMENT WITH QUANTUM AND YOU REPRESENT AND WARRANT THAT YOU HAVE THE AUTHORITY TO BIND SUCH ENTITY TO THESE TERMS. IF EVALUATOR DOES NOT UNCONDITIONALLY AGREE TO ALL OF THE TERMS OF THIS AGREEMENT, USE OF THE SERVICES IS STRICTLY PROHIBITED. IF EVALUATOR HAS EXECUTED, OR SUBSEQUENTLY EXECUTES, AN EVALUATION AGREEMENT OR AN END USER AGREEMENT WITH QUANTUM, THEN THE TERMS AND CONDITIONS OF SUCH EXECUTED EVALUATION AGREEMENT OR END USER AGREEMENT, AS APPLICABLE, SHALL GOVERN AND CONTROL YOUR USE OF THE PRODUCT.  1. **BETA SERVICES**. Quantum is developing a proprietary, set of development tools for quantum computing (the "**Services**"). Evaluator wishes to utilize an evaluation "beta" version of the Services, and Quantum desires to make a beta version of the Services available to Evaluator, subject to the following terms and conditions. Subject to the terms and conditions of this Agreement, Quantum hereby grants Evaluator, during the Term (as defined below), non-exclusive, non-transferable, non-sublicensable right and license to access and use the Services solely for the purpose of evaluating the performance and functionality of the Services (the "**Limited Purpose**"). Evaluator agrees to use and evaluate the Services for a period of ninty days or such other period of time as mutually agreed by the parties in writing (the "**Term**"). Quantum's services outside the scope of this Agreement, if any, shall be provided pursuant to Quantum's then-current applicable services policies and procedures ("**Other Terms**"). Nothing in any of Quantum's Other Terms or any other existing agreements that Evaluator may have with Quantum apply to or are applicable to this Agreement, or Evaluator's use of the Services offered hereunder.  2. **INTELLECTUAL PROPERTY.** The Services (excluding the Evaluator Content hosted thereon), Documentation, and all other materials provided by Quantum hereunder, including but not limited to all manuals, reports, records, programs, data and other materials, and all intellectual property rights in each of the foregoing, are the exclusive property of Quantum and its suppliers. Evaluator agrees that it will not, and will not permit any other party to: (a) permit any party to access the Services or any accompanying documentation ("**Documentation**"); (b) modify, adapt, alter or translate the Services or Documentation; (c) sublicense, lease, rent, loan, distribute, or otherwise transfer the Services or Documentation to any third party; (d) reverse engineer, decompile, disassemble, or otherwise derive or determine or attempt to derive or determine the source code (or the underlying ideas, algorithms, structure or organization) of the Services; (e) use or copy the Services or Documentation except for the Limited Purpose; or (f) publish or disclose to any third party any performance benchmark tests or analyses or other non-public information relating to the Services or the use thereof.  3. **FEEDBACK.** Evaluator understands and agrees that the Services represent a beta test version of unreleased software and services that may contain bugs, defects, and errors. In exchange for the licenses granted to Evaluator to use such software, Evaluator agrees to use good faith efforts to test, use, and evaluate the Services in live operations, and to promptly report to Quantum, either orally or in writing, any errors, problems, defects, or suggestions for changes and improvements to the Services (collectively, "**Feedback**"). Evaluator acknowledges and agrees that all Feedback and all intellectual property rights therein are the exclusive property of Quantum, and hereby assigns to Quantum, all right, title and interest to any and all Feedback. Further, Evaluator acknowledges and agrees that Feedback may be used by Quantum in Quantum's development of and be incorporated into a version of the Services Quantum may make available for commercial distribution ("**Commercial Release**") or any other software or intellectual property created by Quantum. Without limiting the foregoing, Quantum may incorporate Feedback into its products and services and Evaluator will gain no rights in such products or services by virtue of having disclosed Feedback. Evaluator agrees and acknowledges that the products and services incorporating such Feedback will be the sole and exclusive property of Quantum, and Evaluator will gain no right, title or interest in or to the Services, Documentation or any Commercial Release by virtue of Evaluator's provision of Feedback to Quantum or for any other reason. Quantum has no obligation to create, distribute or otherwise offer a Commercial Release, and in the event of such Commercial Release, Quantum has no obligation to offer the Commercial Release to Evaluator or to offer Evaluator any discounted pricing schedules or special terms. Evaluator understands and agrees that the Commercial Release may contain functions and functionality, and perform in a manner significantly different from the current beta version of the Services. Accordingly, Evaluator acknowledges that any research or development performed, or business plans made, by Evaluator regarding or in reliance upon the Services are done entirely at Evaluator's own risk.  4. **DISCLAIMERS OF WARRANTIES.** Evaluator acknowledges that the Services contain prerelease code for testing purposes only and are not at the level of performance and compatibility of a final, generally available product offering. Furthermore, Evaluator acknowledges that the Services may contain bugs, errors, omissions and other problems that could cause system or other failures and data loss. Evaluator acknowledges that Quantum may not introduce a product similar to or compatible with the Services. Accordingly, Evaluator acknowledges that any research, development or other work that   Evaluator performs regarding the Services is done entirely at Evaluator's own risk. To the maximum extent permitted by law, the Services, and all other documentation and materials are provided "AS IS" AND WITH ALL FAULTS. QUANTUM MAKES NO WARRANTIES WITH RESPECT TO THE SERVICES OR DOCUMENTATION, WHETHER EXPRESS OR IMPLIED, INCLUDING WARRANTIES OF TITLE, ACCURACY, INTERFERENCE WITH EVALUATOR'S QUIET ENJOYMENT, SYSTEM INTEGRATION, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK ARISING OUT OF THE USE OR PERFORMANCE OF THE SERVICES IS WITH EVALUATOR NO ORAL OR WRITTEN INFORMATION OR ADVICE GIVEN BY QUANTUM OR ITS AGENTS OR EMPLOYEES SHALL IN ANY WAY INCREASE THE SCOPE OF THIS WARRANTY.  5. **LIMITATION OF LIABILITY.** IN NO EVENT WILL QUANTUM OR ITS LICENSORS (IF ANY) BE LIABLE TO EVALUATOR OR ANY THIRD PARTY FOR THE COST OF PROCUREMENT OF SUBSTITUTE SERVICES, LOST PROFITS, LOST DATA, OR ANY SPECIAL, INDIRECT, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY ARISING IN ANY WAY OUT OF THIS AGREEMENT OR EVALUATOR'S USE OF THE SERVICES, EVEN IF QUANTUM HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. THE TOTAL CUMULATIVE LIABILITY, RELATED TO THIS AGREEMENT, OF QUANTUM AND ITS LICENSORS (IF ANY) SHALL BE LIMITED TO FIFTY DOLLARS (U.S. $50). The parties agree that the limitations of liability set forth in this section shall survive and continue in full force and effect despite any failure of consideration or of an exclusive remedy. The parties acknowledge that the prices have been set and the Agreement entered into in reliance upon these limitations of liability and that all such limitations form an essential basis of the bargain between the parties.  6. **CONFIDENTIALITY.** The structure, sequence, organization and code of the software used to provide the Services constitute valuable trade secrets of Quantum and its suppliers. Evaluator will not disclose to any third party: any information about the Services, including its existence, design, performance characteristics, feedback, and test results. Evaluator will use reasonable efforts to prevent any access to the Services by anyone other than its employees who are obligated to comply with the terms hereof.  7. **PRODUCT DIAGNOSTIC REPORTING.** Evaluator acknowledges that the Services will store certain diagnostic information about the routine operations of the Services (including, without limitation, its performance, data reduction ratios, configuration data, and any software faults) and will periodically transmit this diagnostic information to Quantum. Evaluator agrees that Quantum has a perpetual, irrevocable, worldwide, sublicenseable, and royalty-free right to use this diagnostic information in any manner and that Evaluator will not interfere with the collection or transmission of such information to Quantum. For clarification, there is no actual user data of Evaluator that is transmitted or provided to Quantum.  8. **TERM AND TERMINATION.** This Agreement commences upon the Effective Date and will continue in effect until the end of the Term. Either party may terminate this Agreement upon written notice to the other party. Upon termination, Evaluator shall immediately cease all use of Services, and delete or destroy all copies of the Documentation in the possession or control of Evaluator.  9. **GENERAL PROVISIONS.** This Agreement will be governed by the laws of the State of Colorado. Evaluator submits to the exclusive jurisdiction and venue of the federal and state courts located in Denver County, Colorado for any disputes arising out of or related to this Agreement. Evaluator may not assign or transfer, by operation of law, change of control or otherwise, any of its rights under this Agreement to any third party without Quantum's prior written consent. Any attempted assignment or transfer in violation of the foregoing will be void. All waivers must be in writing. Any waiver or failure to enforce any provision of this Agreement on one occasion will not be deemed a waiver of any other provision or of such provision on any other occasion. If any part of this Agreement is found void and unenforceable, it will not affect the validity of the balance of this Agreement, which shall remain valid and enforceable according to its terms. If any provision of this Agreement is, for any reason, held to be invalid or unenforceable, the other provisions of this Agreement will remain enforceable and the invalid or unenforceable provision will be deemed modified so that it is valid and enforceable to the maximum extent permitted by law.


pkgId: ad41a245242f3cff255844bb5920c5e88ba0c93217b8eb47266e166ddde7891f
name: python-QubiPy-help
arch: noarch
version: 0.2.3
epoch: 0
release: 1
summary: Development documents and examples for QubiPy
url: https://github.com/QubiPy-Labs/QubiPy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-QubiPy-0.2.3-1.src.rpm
location_href: Packages/python-QubiPy-help-0.2.3-1.noarch.rpm
checksum_type: sha256
description:
  Currently, QubiPy is in a very early development phase, so please take this into consideration before using the library.

  Visit [Change log](CHANGELOG.md)

  ![v0.2.3](https://img.shields.io/badge/beta_version-0.2.3-green)


  QubiPy is in beta phase and may change considerably until the stable version. Keep this in mind when using the library.

  To install the necessary dependencies, run this command in the console :
  ```
  $ pip install -r requirements.txt
  ```


  You have two ways to use QubiPy, one is by PyPi or by cloning the project from the official repository.

  To use the module, it is necessary to import some modules before :
  ```python
  from qubipy.rpc import rpc_client
  from qubipy.core import core_client
  ```

  Let's request tick info from the RPC for example :

  ```python
  RPC = rpc_client.QubiPy_RPC()
  print(RPC.get_tick_info())
  ```
  Response :
  ```python
  $ {
    "tick": 16660254,
    "duration": 1,
    "epoch": 131,
    "initialTick": 16640000
  }
  ```
  Let's request the entity info from the core :
  ```python
  CORE = core_client.QubiPy_Core()
  print(CORE.get_entity_info('PEKBRHZQKMGCQBTAHXHZRXQRLBACJIHAGWHMPIJTZBWIJVTIWQOVMGJDTPFO'))
  ```
  Reponse :
  ```python
  $ {
    "entity": {
      "id": "PEKBRHZQKMGCQBTAHXHZRXQRLBACJIHAGWHMPIJTZBWIJVTIWQOVMGJDTPFO",
      "incomingAmount": "113653127220",
      "outgoingAmount": "80838490981",
      "numberOfIncomingTransfers": 824156,
      "numberOfOutgoingTransfers": 422,
      "latestIncomingTransferTick": 16613012,
      "latestOutgoingTransferTick": 16613029
    },
    "validForTick": 16660147,
    "spectrumIndex": 7434551,
    "siblingIds": [
      "GIDNABDPPDFPECDPYUQZEBZONVJAXCTRQXRGHCLPNAOMEAHMULYQBQQEZRBE",
      "WUTXDWZRYSBHOEHBZSVCWIRXSAPAZFMZSJFHOGDTIAYOPAIKGUNGIOLEVFVO",
      "NZUUNSQJEAXQAACZVEGHEHDNQRLDZRHXDJKCJLCXODFQQJTHGCMIRZDFAXBD",
      "HFSHRQUTQONGFDTXKPPAGHEMJSHBLTWVQKZMKVGYYEDSTPBIRBTMHSRCUKUO",
      "PGXXITTPEGARXGSHDTBVFYRVBXFHZBXPIQQNBQKJHEGXZGDTTCYGITFGSKBG",
      "EFEDDOBGUVASHBTCYRCUZOXQTLUDMKMCEYFHDLETIFAUDPLYOZYQUPEBAXGC",
      "DNYAQMGQRFCUMBUCEIFRNYSCYUXDWNWTTLFQQFDCEBVCTOWGLVXLCNBESPJE",
      "MSWZOKQKAWZUECKOEWOPMNUBSQSDAHTHYIFMSYRRKBZSJJLHLECBOUUDNNHO",
      "RGHPZOHWBHKIICUGBENRQPKDJHJDLIFKETGMKMPMTAJGRTPIOKCPETRDPBME",
      "CADVHWJMDNOJJGPDAVPYOUNDPWEABLSDLPGHCWJWGDFTYIVFBAZIBTDBQKVL",
      "AEMCJNNWDXBRSFEZVXAHFDPLNBJHMMMDBLKPVETCQFCZFJWEVEEXANUBUMCM",
      "BTOZFRHDVNYUVAMHNBBZJTNMCVZBORRPFNQIZZPRDEMHIFPWTFSARQVBMATC",
      "SHWFJGOAMBUIJDDSKCWAMOIWBNJHUUDHRDDHRBORSDCCSJLSSCDGXOKCVWMB",
      "XTOYTMZTUTPPVGBWYCVIFDVMLLWFIMXRZKOGUHJLADMIKLZTIPQJPLKCGVUB",
      "ZVBYCOZKUMZRTBIAYVWUTWUGYNQEPASOMENYCCERUDCYFHKMIQDLCVNCZCVA",
      "GHGNSBIOBLCIRGBBEKQZOSTKXJGHXWUYVNLRCTSBUENITLCSDIBNSDBBITQL",
      "PKFLHUYXWAELGGXBXTRRASNCQZSEDURLIUXKEDHTYFAIASIPPTSBVYMCQTWB",
      "OCOVEQIPGTUPIBAYGYDOSAWXWIGBKDBVKIFARQSHWAUUYSYVLKZITMZCMHCI",
      "NAPHRLGCLNNKVERLZDIGIFADQSLAZYUULTBAGCDYEEDSBFZGCCLXZXDGSBKK",
      "IGIZMDVOTFEJTFXHXURCUXNOSCDFJJJHTTTSRGABECNPKMJFZQTTEKOBSDFH",
      "OHEMQVDLSQLQQAVHTYOKFPZUOHIBNBWJITCHETOBUAAPWWFSYACPPSMEHSEE",
      "LPJMDKCKOOYGBFAEXDRZCALQUIIALWMHFSAEJUUBKBQXRPDYCXEXKMYDDJIO",
      "HGDFFPYTXOKSMGYMXPFEPLCQXXLDRULLJEIAYOVZBFABJIYZHVNSLRAENXUG",
      "ZQLSECAGXOUHNEFFBATFQIBYAYYDECSPKVHNGGJIPEGNSIUWNORASTNAUFYL"
    ]
  }

  ```

  To learn more about the library, please visit our official [documentation]().


  This library is using `crypto.dll` which is a C extension of Qubic key utility functions and bind it to Python. To build this `crypto.dll`, this repository was used: [https://github.com/serendipity-seeker/key-utils-binding](https://github.com/serendipity-seeker/key-utils-binding).


pkgId: 0fd305fc7545cdfc2d32ab75b8e1b3fa6ec81a0366fefc9e3b21ac813e6d8a3a
name: python-REFPROP-connector-help
arch: noarch
version: 0.3.14
epoch: 0
release: 1
summary: Development documents and examples for REFPROP-connector
url: https://www.dief.unifi.it/vp-177-serg-group-english-version.html
rpm_license: GNU GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-REFPROP-connector-0.3.14-1.src.rpm
location_href: Packages/python-REFPROP-connector-help-0.3.14-1.noarch.rpm
checksum_type: sha256
description:
  __REFPROP connector__ is a tools developed by the [SERG research group](https://www.dief.unifi.it/vp-177-serg-group-english-version.html)
  of the [University of Florence](https://www.unifi.it/changelang-eng.html) for launching [REFPROP](https://www.nist.gov/srd/refprop)
  calculation and retrieving results from python.

  In order to use the code you must have both REFPROP and the [REFPROP wrappers for Python](https://github.com/usnistgov/REFPROP-wrappers)
  installed and properly working.

  The scope of this library is to make the usage of the refprop wrappers simpler.



  The beta version can be downloaded using __PIP__:

  ```
  pip install REFPROP_connector
  ```


  Once the installation has been completed the user can import the tool and initialize the connector itself.
  ```python
  from REFPROPConnector import ThermodynamicPoint

  tp = ThermodynamicPoint(["air"], [1.])

  ```
  __An important aspects to keep in mind for the initialization:__

    * A file-dialog __could__ appear the first time that the connector is imported __asking the user to select the REFPROP
      installation folder__ (usually it's _"C:\Program Files (x86)\REFPROP"_).
      Once the executable path has been selected, the program will keep it in memory in order to avoid a new appearance
      of the file-dialog. The stored executable can be modified calling the following function:

  ```python
  from REFPROPConnector import retreive_RP_exec

  retreive_RP_exec()
  ```

  If you have multiple or conflicting REFPROP installations, you can force the program not to use the default executable
  path by using the option:
  ```python
  from REFPROPConnector import retreive_RP_exec

  retreive_RP_exec(ignore_default=True)
  ```

  Alternatively you can explicitly provide the installation folder path using
  ```python
  from REFPROPConnector import retreive_RP_exec

  retreive_RP_exec(file_path="<your path to RP installation>")
  ```

  __IMPORTANT:__ Each time you run *"retreive_RP_exec"* open the program that is executing your python code (such as the
  Terminal, PyCharm or Spider) in *administrator mode* otherwise the call may not have any effect.



  Each _ThermodynamicPoint_ class instance represent a thermodynamic state, hence you had to provide at least
  __two indipendent state variables__ in order to calculate the others.


  ```python
  from REFPROPConnector import ThermodynamicPoint

  tp = ThermodynamicPoint(["water"], [1.])

  tp.set_variable("P", 0.101325)     # P in MPa (ambient pressure)
  tp.set_variable("Q", 0.5)          # vapour quality for multiphase condition

  T_sat = tp.get_variable("T")       # saturation temperature in celsius (100 °C)
  ```



  _AbstractThermodynamicPoint_ is a class that can be overwritten in order to perform some calculation once both
  independent state variable have been set. It can be useful for example for the evaluation of the reynolds number
  for a fluid flowing in a pipe.

  ```python
  from REFPROPConnector import AbstractThermodynamicPoint, RefPropHandler, init_handler
  import numpy as np


  class TubeSection(AbstractThermodynamicPoint):

      def __init__(self, diam, flow_rate):

          self.diam = diam
          self.area = np.pi * np.power(diam / 2, 2)
          self.flow_rate = flow_rate
          self.Re = 0.

          refprop = init_handler(

              chosen_subclass=RefPropHandler,
              fluids=["air"], composition=[1]

          )

          super().__init__(refprop)

      def other_calculation(self):

          mu = self.get_variable("mu") / (10 ** 6)  # conversion uPa*s -> Pa*s
          self.Re = self.flow_rate * self.diam / (self.area * mu)

  if __name__ == "__main__":

      section = TubeSection(0.5, 1)

      """

          The following line will return 0. as the function "other_calculation"
          is called only when 2 independent state variables are provided

      """
      print(section.get_variable("Re"))

      section.set_variable("P", 0.5)
      section.set_variable("T", 20)

      """

          The following line will return the actual Reynolds number

      """
      print(section.get_variable("Re"))
  ```



  Variable that can be calculated can be listed using _list_properties_ method from both _ThermodynamicPoint_ and
  _AbstractThermodynamicPoint_ (the name __is not case-sensitive__). Finally, user can also select the unit system to be
  used in the calculation, a list of possible unit system can be revived calling the method _list_unit_systems()_
  (current unit_system will be highlighted):

  ```python
  from REFPROPConnector import ThermodynamicPoint

  tp = ThermodynamicPoint(["water"], [1.], unit_system="MASS BASE SI")
  tp.list_properties()
  tp.list_unit_systems()
  ```
  Default unit system is __SI with C__



  You can force the state to represent a metastable condition as follows:

  ```python
  from REFPROPConnector import ThermodynamicPoint

  tp = ThermodynamicPoint(["water"], [1.], unit_system="MASS BASE SI")
  tp.metastability = "liq" # or "vap" for vapour metastable condition
  ```
  Acceptable keywords for metastability are ["liquid", "liq", "l", ">"] for the liquid metastable state,
  or ["vap", "vapour", "vapor", "v", "<"] for the vapour state (keywords **are not** case-sensitive).




  You can evaluate either the static point given the total condition and the speed or the stagnation
  condition given the static ones by using the following commands:
  ```python
  from REFPROPConnector import ThermodynamicPoint

  tp = ThermodynamicPoint(["water"], [1.], unit_system="MASS BASE SI")
  speed = 300     # m/s
  static_point = tp.get_static_point(speed=speed)
  total_point = tp.get_stagnation_point(speed=speed)

  ```
  The speed value must be ginve in m/s!


  The _DiagramPlotter_ class can be used to plot a specific state diagram that can be then used to describe state
  transformations. The diagram can be personalized using the _DiagramPlotterOptions_ class.
  The following is an example on how to use the class.


  ```python
  from REFPROPConnector import (

      ThermodynamicPoint,
      DiagramPlotter,
      DiagramPlotterOptions

  )

  tp = ThermodynamicPoint(["Carbon Dioxide"], [1])
  options = DiagramPlotterOptions(

      x_variable="T",
      x_var_range = (0, 150), x_var_log=False,
      y_var_range = (4, 15),
      isoline_ranges={

          "rho": (50, 1000, 25),
          "H": (200, 550, 25)

      }

  )
  plotter = DiagramPlotter(tp, options=options)
  plotter.calculate()

  fig, (ax_1) = plt.subplots(1, 1, dpi=200)
  fig.set_size_inches(10, 5)
  plotter.plot(ax_1)
  plt.show()
  ```

  __-------------------------- !!! THIS IS A BETA VERSION !!! --------------------------__

  please report any bug or problems in the installation to _pietro.ungar@unifi.it_<br/>


pkgId: ff9becc075fd3f275db1b401e29d0d3c82f4292678ee8cb90d094dfce89557d7
name: python-ROKSANA-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for ROKSANA
url: https://github.com/radinhamidi/roksana
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ROKSANA-0.2.0-1.src.rpm
location_href: Packages/python-ROKSANA-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  ROKSANA is a Python toolkit for performing keyword search and attack methods on user-provided datasets.



  - **Custom Datasets:** Bring your own dataset using PyG Geometric's dataset structure.
  - **Search Methods:** Choose from pre-defined keyword search methods.
  - **Attack Methods:** Utilize pre-defined attack methods or implement your own.
  - **Result Handling:** Save results to files in various formats.
  - **Leaderboard Integration:** Submit your results to the leaderboard.



  ```bash
  pip install roksana
  ```



  To evaluate the effectiveness of the search methods, you can prepare a search set consisting of query nodes and their corresponding gold sets. The gold set for each query consists of all nodes in the dataset that share the exact same feature vector as the query node.



  ```python
  from roksana.datasets import prepare_search_set


  queries, gold_sets = prepare_search_set(data, percentage=0.1, seed=42)
  ```



  ROKSANA provides a suite of attack methods to evaluate the robustness of your search algorithms. Currently, the package includes predefined attack methods that you can leverage out-of-the-box or extend with your custom implementations.



  - `random`: Randomly adds or removes edges connected to the query node.
  - `viking`: Perturbs the feature vectors of the query node.



  ```python
  from roksana.datasets import load_dataset, prepare_test_set
  from roksana.attack_methods import get_attack_method
  ```


  ```python
  dataset = load_dataset(dataset_name='cora', root='data/')
  data = dataset[0]
  ```


  ```python
  queries, gold_sets = prepare_test_set(data, percentage=0.1, seed=123)
  ```


  ```python
  attack_method = get_attack_method('predefined_attack1', data=data, perturbations=2)
  ```


  ```
  for query_node in queries:
      attack_details = attack_method.attack(query_node=query_node, perturbations=2)
      print(f"Attack on Node {query_node}: {attack_details}")
  ```



  The **Evaluation** module in ROKSANA provides tools to assess the effectiveness of attack strategies on your search methods. By computing key metrics—**Hit@k**, **Recall@k**, and **Demotion Value**—you can quantify how attacks influence the performance and reliability of your search algorithms.



  1. **Hit@k**
     - **Definition:** Measures whether at least one relevant node (from the gold set) appears in the top-k retrieved nodes.
     - **Interpretation:** Higher values indicate better performance in retrieving relevant nodes within the top-k results.

  2. **Recall@k**
     - **Definition:** Quantifies the proportion of relevant nodes that are retrieved in the top-k results.
     - **Interpretation:** Higher values signify that a larger fraction of relevant nodes are captured within the top-k retrieved nodes.

  3. **Demotion Value**
     - **Definition:** Measures the change in the rank of a target node (typically the query node itself) before and after an attack.
     - **Interpretation:** Positive values indicate that the target node has been ranked lower post-attack, reflecting the attack's effectiveness in degrading its visibility.



  Here's a step-by-step guide to evaluating the impact of an attack on a search method.



  ```python
  from roksana.datasets import load_dataset, prepare_test_set
  ```


  ```python
  dataset = load_dataset(dataset_name='cora', root='data/')
  data = dataset[0]
  ```


  ```python
  queries, gold_sets = prepare_test_set(data, percentage=0.1, seed=123)
  ```



  ROKSANA provides utility functions to save evaluation results in various formats, including JSON, CSV, and Pickle. These functions are located within the `evaluation.utils` module.



  - `save_results_to_json(results: List[Dict[str, Any]], filepath: str) -> None`
  - `save_results_to_csv(results: List[Dict[str, Any]], filepath: str) -> None`
  - `save_results_to_pickle(results: List[Dict[str, Any]], filepath: str) -> None`



  ```python
  from roksana.evaluation import save_results_to_csv, save_results_to_json, save_results_to_pickle


  results = [
      {
          'query_node': 0,
          'k': 5,
          'Hit@k_before_attack': 1.0,
          'Hit@k_after_attack': 0.0,
          'Recall@k_before_attack': 0.5,
          'Recall@k_after_attack': 0.3,
          'Demotion_value': 2
      },
      
  ]


  save_results_to_csv(results, 'evaluation_results/results.csv')
  save_results_to_json(results, 'evaluation_results/results.json')
  save_results_to_pickle(results, 'evaluation_results/results.pkl')
  ```


pkgId: 44eaa089afa2edebdc1c9f6c1f25a60f4d9fc036e43af6e8523c3d39a8301cfc
name: python-Radicale-help
arch: noarch
version: 3.3.2
epoch: 0
release: 1
summary: Development documents and examples for Radicale
url: https://radicale.org/
rpm_license: GNU GPL v3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Radicale-3.3.2-1.src.rpm
location_href: Packages/python-Radicale-help-3.3.2-1.noarch.rpm
checksum_type: sha256
description:
  [![Test](https://github.com/Kozea/Radicale/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/Kozea/Radicale/actions/workflows/test.yml)
  [![Coverage Status](https://coveralls.io/repos/github/Kozea/Radicale/badge.svg?branch=master)](https://coveralls.io/github/Kozea/Radicale?branch=master)

  Radicale is a small but powerful CalDAV (calendars, to-do lists) and CardDAV
  (contacts) server, that:

  * Shares calendars and contact lists through CalDAV, CardDAV and HTTP.
  * Supports events, todos, journal entries and business cards.
  * Works out-of-the-box, no complicated setup or configuration required.
  * Can limit access by authentication.
  * Can secure connections with TLS.
  * Works with many CalDAV and CardDAV clients
  * Stores all data on the file system in a simple folder structure.
  * Can be extended with plugins.
  * Is GPLv3-licensed free software.

  For the complete documentation, please visit
  [Radicale master Documentation](https://radicale.org/master.html).

  Additional hints can be found
  * [Radicale Wiki](https://github.com/Kozea/Radicale/wiki)
  * [Radicale Issues](https://github.com/Kozea/Radicale/issues)
  * [Radicale Discussions](https://github.com/Kozea/Radicale/discussions)

  Before reporting an issue, please check
  * [Radicale Wiki / Reporting Issues](https://github.com/Kozea/Radicale/wiki/Reporting-Issues)


pkgId: ea71aaa5cff12397d52c6a61d44d5af48ac91cc859cae9dd6fc4ada1b55a0b4a
name: python-ReFrame-HPC-help
arch: noarch
version: 4.7.2
epoch: 0
release: 1
summary: Development documents and examples for ReFrame-HPC
url: https://github.com/reframe-hpc/reframe
rpm_license: BSD 3-Clause
rpm_group: Unspecified
rpm_buildhost: vm-2p8g.taishan200-2280-2s48p-256g--a63-0.compass-ci.net
rpm_sourcerpm: python-ReFrame-HPC-4.7.2-1.src.rpm
location_href: Packages/python-ReFrame-HPC-help-4.7.2-1.noarch.rpm
checksum_type: sha256
description:
  [![ReFrame Logo](https://raw.githubusercontent.com/reframe-hpc/reframe/master/docs/_static/img/reframe_logo-width400p.png)](https://github.com/reframe-hpc/reframe)<br/>
  [![Build Status](https://github.com/reframe-hpc/reframe/workflows/ReFrame%20CI/badge.svg)](https://github.com/reframe-hpc/reframe/actions?query=workflow%3A%22ReFrame+CI%22)
  [![Documentation Status](https://readthedocs.org/projects/reframe-hpc/badge/?version=latest)](https://reframe-hpc.readthedocs.io/en/latest/?badge=latest)
  [![codecov.io](https://codecov.io/gh/reframe-hpc/reframe/branch/master/graph/badge.svg)](https://codecov.io/github/reframe-hpc/reframe)<br/>
  ![GitHub release (latest by date including pre-releases)](https://img.shields.io/github/v/release/reframe-hpc/reframe?include_prereleases)
  ![GitHub commits since latest release](https://img.shields.io/github/commits-since/reframe-hpc/reframe/latest)
  ![GitHub contributors](https://img.shields.io/github/contributors-anon/reframe-hpc/reframe)<br/>
  [![PyPI version](https://badge.fury.io/py/ReFrame-HPC.svg)](https://badge.fury.io/py/ReFrame-HPC)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/reframe-hpc)
  [![Downloads](https://pepy.tech/badge/reframe-hpc)](https://pepy.tech/project/reframe-hpc)
  [![Downloads](https://pepy.tech/badge/reframe-hpc/month)](https://pepy.tech/project/reframe-hpc)<br/>
  [![Slack](https://badgen.net/badge/icon/slack?icon=slack&label)](https://join.slack.com/t/reframetalk/shared_invite/zt-1tar8s71w-At0tolJ~~zxT2oG_2Ly9sw)
  [![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
  [![DOI](https://zenodo.org/badge/89384186.svg)](https://zenodo.org/badge/latestdoi/89384186)<br/>
  [![Twitter Follow](https://img.shields.io/twitter/follow/ReFrameHPC?style=social)](https://twitter.com/ReFrameHPC)



  ReFrame is a powerful framework for writing system regression tests and benchmarks, specifically targeted to HPC systems.
  The goal of the framework is to abstract away the complexity of the interactions with the system, separating the logic of a test from the low-level details, which pertain to the system configuration and setup.
  This allows users to write portable tests in a declarative way that describes only the test's functionality.

  Tests in ReFrame are simple Python classes that specify the basic variables and parameters of the test.
  ReFrame offers an intuitive and very powerful syntax that allows users to create test libraries, test factories, as well as complete test workflows using other tests as fixtures.
  ReFrame will load the tests and send them down a well-defined pipeline that will execute them in parallel.
  The stages of this pipeline take care of all the system interaction details, such as programming environment switching, compilation, job submission, job status query, sanity checking and performance assessment.

  Please visit the project's documentation [page](https://reframe-hpc.readthedocs.io/) and [GitHub repository](https://github.com/reframe-hpc/reframe) for all the details!



  You can get in contact with the ReFrame community in the following ways:



  Please join the community's [Slack channel](https://reframe-slack.herokuapp.com) for keeping up with the latest news about ReFrame, posting questions and, generally getting in touch with other users and the developers.



  ReFrame is an open-source project and we welcome and encourage contributions!
  Check out our Contribution Guide [here](https://github.com/reframe-hpc/reframe/wiki/contributing-to-reframe).



  You can cite ReFrame in publications as follows:

  > Vasileios Karakasis et al. “Enabling Continuous Testing of HPC Systems Using ReFrame”. In: *Tools and Techniques for High Performance Computing. HUST - Annual Workshop on HPC User Support Tools* (Denver, Colorado, USA, Nov. 17–18, 2019). Ed. by Guido Juckeland and Sunita Chandrasekaran. Vol. 1190. Communications in Computer and Information Science. Cham, Switzerland: Springer International Publishing, Mar. 2020, pp. 49–68. isbn: 978-3-030-44728-1. doi: 10.1007/978-3-030-44728-1_3.

  The corresponding BibTeX entry is the following:

  ```bibtex
  @InProceedings{karakasis20a,
    author     = {Karakasis, Vasileios and Manitaras, Theofilos and Rusu, Victor Holanda and
                  Sarmiento-P{\'e}rez, Rafael and Bignamini, Christopher and Kraushaar, Matthias and
                  Jocksch, Andreas and Omlin, Samuel and Peretti-Pezzi, Guilherme and
                  Augusto, Jo{\~a}o P. S. C. and Friesen, Brian and He, Yun and Gerhardt, Lisa and
                  Cook, Brandon and You, Zhi-Qiang and Khuvis, Samuel and Tomko, Karen},
    title      = {Enabling Continuous Testing of {HPC} Systems Using {ReFrame}},
    booktitle  = {Tools and Techniques for High Performance Computing},
    editor     = {Juckeland, Guido and Chandrasekaran, Sunita},
    year       = {2020},
    month      = mar,
    series     = {Communications in Computer and Information Science},
    volume     = {1190},
    pages      = {49--68},
    address    = {Cham, Switzerland},
    publisher  = {Springer International Publishing},
    doi        = {10.1007/978-3-030-44728-1_3},
    venue      = {Denver, Colorado, USA},
    eventdate  = {2019-11-17/2019-11-18},
    eventtitle = {{HUST} - Annual Workshop on {HPC} User Support Tools},
    isbn       = {978-3-030-44728-1},
    issn       = {1865-0937},
  }
  ```


pkgId: 74cdd9100dfcfd38639b54aaaaabe8c14ab587687b2c15aa4a0c7afe4f7508ab
name: python-RequirementsCheck-help
arch: noarch
version: 0.0.4
epoch: 0
release: 1
summary: Development documents and examples for RequirementsCheck
url: https://github.com/bbilly1/requirementscheck
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-RequirementsCheck-0.0.4-1.src.rpm
location_href: Packages/python-RequirementsCheck-help-0.0.4-1.noarch.rpm
checksum_type: sha256
description:
  Core Functionality:
  - Look for requirements*.txt files in your working directory and check for updates.
  - Prompt to confirm each update with an upstream url.



  Install into your environment with pip:

  ```
  pip install requirementscheck
  ```

  Add it to your `requirements.txt` file, pin the release, and use requirementscheck to update requirementscheck in your `requirements.txt` file.



  From your Python project root folder run:
  ```
  requirementscheck
  ```

  to look for requirements files and update your dependencies based on your prompts.

  Additionally, this takes to optional arguments:

  - `--confirm | --no-confirm`: Ask for confirmation with link to upstream package before applying update, default `True`.
  - `--pin | --no-pin`: Pin a dependency to the latest version if found to be not pinned, default `False`.
  - `-h | --help`: Print help text and exit.



  Run tests:
  ```
  python -m unittest src/requirementscheck/test_requirementscheck.py
  ```

  1. Update the version in setup.py
  2. Git Tag
  3. Push tag
  4. Create release on GH
  5. Build and update package to pypi:

      ```bash
      python -m build
      python -m twine upload dist/*
      ```


  Newest docs on GitHub: [bbilly1/requirementscheck](https://github.com/bbilly1/requirementscheck).


pkgId: 7691374de6d62d4dc5a2798bbeb32a1d3d79671773088a2aba4600b2fc0e40ba
name: python-ResSimpy-help
arch: noarch
version: 2.3.9
epoch: 0
release: 1
summary: Development documents and examples for ResSimpy
url: https://pypi.org/project/ResSimpy/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ResSimpy-2.3.9-1.src.rpm
location_href: Packages/python-ResSimpy-help-2.3.9-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/pypi/l/ressimpy)](https://github.com/bp/ResSimpy/blob/master/LICENSE.MD)
  [![Documentation Status](https://readthedocs.org/projects/ressimpy/badge/?version=latest)](https://ResSimpy.readthedocs.io/en/latest/?badge=latest)
  [![Python CI](https://github.com/bp/ResSimpy/actions/workflows/ci-tests.yml/badge.svg)](https://github.com/bp/ResSimpy/actions/workflows/ci-tests.yml)
  ![Python version](https://img.shields.io/pypi/pyversions/ResSimpy)
  [![PyPI](https://img.shields.io/pypi/v/ResSimpy)](https://badge.fury.io/py/ResSimpy)
  ![Status](https://img.shields.io/pypi/status/ResSimpy)
  [![codecov](https://codecov.io/gh/bp/ResSimpy/branch/master/graph/badge.svg)](https://codecov.io/gh/bp/ResSimpy)


  **ResSimpy** is a Python API for automating reservoir simulation workflows, allowing the user to read, manipulate and
  write reservoir simulation input decks. Whilst it was created by staff at BP, we welcome contributions from anybody
  interested, whether it is by raising pull requests, or simply suggesting features / raising bugs in the [GitHub issues](https://github.com/bp/ResSimpy/issues).



  See the complete package documentation on
  [readthedocs](https://ResSimpy.readthedocs.io/).



  ResSimpy can be installed with pip:

  ```bash
  pip install ressimpy
  ```



  Please see [Contributing Guide](docs/CONTRIBUTING.rst) for instructions on how to set up a dev environment and contribute
  code to the project.


  The following Python code examples demonstrate how to perform some simple operations on a model using ResSimpy:


  ```python
  from ResSimpy import NexusSimulator as Simulator
  ```


  ```python
  nexus_fcs_file = '/path/to/fcsfile.fcs'
  model = Simulator(origin=nexus_fcs_file) # Create the 'Simulator' model object
  ```




  ```python


  model.update_simulator_files()


  model.write_out_new_simulator(new_file_path='/new/path/to/fcsfile.fcs', new_include_file_location='/new/path/to/includes_directory/')
  ```


  ```python
  wells_info = model.wells.get_wells_overview() # Returns a list of wells with their information. Can be print()ed
  print(wells_info)
  ```


  ```python
  well = model.wells.get(well_name='well_1') # Retrieves the named well as a NexusWell object


  perforations = well.perforations


  print(well.printable_well_info)


  wells_df = model.wells.get_df()
  print(wells_df)
  ```


  ```python

  new_completion = {'date': '01/02/2025', 'i': 4, 'j': 5, 'k': 6, 'well_radius': 7.50} # Create a dictionary containing the properties of the completion you wish to add
  model.wells.add_completion(well_name='well_1', completion_properties=new_completion) # Add the new completion


  completion_to_modify = {'date': '01/02/2025', 'i': 4, 'j': 5, 'k': 6, 'well_radius': 7.5} # Create a dictionary containing the properties of the existing completion
  model.wells.remove_completion(well_name='well_1', completion_properties=completion_to_modify) # Remove the completion


  modified_properties = {'date': '10/03/2025'} # Create a dict with the properties you want to change and their new values
  model.wells.modify_completion(well_name='well_1', properties_to_modify=modified_properties, completion_to_change=completion_to_modify) # Modify the completion
  ```


  ```python
  func_list = model.grid.get_array_functions_list()
  func_summary_df = model.grid.get_array_functions_df() # get a dataframe instead

  [print(x) for x in func_list[0:9]] # Example showing how to print out the first 10 functions
  ```


  ```python
  constraints = model.network.constraints.get_all()
  constraints_for_well = constraints['well_1'] # Get the constraints for the well well_1


  oil_rate = constraints_for_well[0].max_surface_oil_rate
  print(f"\nmax surface oil rate: {oil_rate}")


  constraint_df = model.network.constraints.get_df()
  print(constraint_df)
  ```


  ```python
  df_well_cons = model.network.connections.get_df()
  df_well_bores = model.network.wellbores.get_df()
  df_connections = model.network.connections.get_df()
  df_nodes = model.network.nodes.get_df()
  ```


  For most bugs or feature requests, we recommend using [GitHub issues](https://github.com/bp/ResSimpy/issues).
  If, however, you have a query related to something else, or if your query relates to something confidential, please feel
  free to email the team at ResSimpy@bp.com.


pkgId: 7f20b95045cf2d35e2a1a9371d38265ca6f4df8272b34aa46a00559afad040c6
name: python-ReverseBox-help
arch: noarch
version: 0.20.8
epoch: 0
release: 1
summary: Development documents and examples for ReverseBox
url: https://github.com/bartlomiejduda/ReverseBox
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ReverseBox-0.20.8-1.src.rpm
location_href: Packages/python-ReverseBox-help-0.20.8-1.noarch.rpm
checksum_type: sha256
description:
  **ReverseBox** is a Python package with a set of functions
  useful in software reverse engineering.

  **Why ReverseBox?** <br>
  It's designed to help with:
  1. Decompressing / compressing data
  2. Decrypting / encrypting data
  3. Tedious reverse engineering tasks
  e.g. testing different checksum algorithms to find the one that was
  used in the software or file format
  4. Figuring out file formats
  5. Parsing data structures
  6. Wrapping functions for input/output operations
  7. Searching for raw images

  **Who should use ReverseBox?** <br>
  Mostly developers and reverse engineers (e.g. file format researchers
  or software researchers).



  * Checksum
    - Adler32 ✔️
    - Fletcher16 ✔️
    - Fletcher32 ✔️
    - Internet Checksum / IPv4 header checksum ✔️
    - Sum8 ✔️
    - Sum8 2s Complement ✔️
    - Unix Sum BSD16 ✔️
    - Unix Sum SYSV ✔️
    - Xor8 ✔️

  * CRC
    - CRC-8 ✔️
    - CRC-8/CDMA2000 ✔️
    - CRC-8/DARC ✔️ <span style="color:yellow">(wrapper only)</span>
    - CRC-16 (ARC) ✔️
    - CRC-16 (Modbus) ✔️
    - CRC-16 (Sick) ✔️
    - CRC-16 (DNP) ✔️
    - CRC-16 (EA CRCF) ✔️
    - CRC-16-CCITT (XModem) ✔️
    - CRC-16-CCITT (0xFFFF) ✔️
    - CRC-16-CCITT (0x1D0F) ✔️
    - CRC-16-CCITT (Kermit) ✔️
    - CRC-32/CKSUM (Unix cksum) ✔️
    - CRC-32 (ISO/HDLC) ✔️
    - CRC-32 (Asobo) ✔️
    - CRC-64 (Asobo) ✔️
    - CRC-64/GO-ISO ✔️ <span style="color:yellow">(wrapper only)</span>

  * Compression
    - Asobo (TODO) ❌
    - BZE/BZZ (TODO) ❌
    - BZIP2 (TODO) ❌
    - GZIP (TODO) ❌
    - JCALG1 (TODO) ❌
    - LZMA (TODO) ❌
    - LZO / LZO1X ✔️ <span style="color:yellow">(wrapper only)</span>
    - LZSS (TODO) ❌
    - MIO0 ✔️
    - NitroSDK (TODO) ❌
    - Oodle (TODO) ❌
    - Refpack (EA Games) ✔️ <span style="color:yellow">(wrapper only)</span>
    - RNC (TODO) ❌
    - ZLIB ✔️ <span style="color:yellow">(wrapper only)</span>

  * Encryption
    - AES (TODO) ❌
    - DES (TODO) ❌
    - Lucifer / DTD-1 (TODO) ❌
    - ROT13 ✔️
    - XOR Cipher (Basic) ✔️
    - XOR Cipher (Basic) Guesser ✔️
    - (game-specific) XOR Cipher (Retro64 ECO) ✔️
    - (game-specific) XOR Cipher (Giana’s Return ZDA) ✔️

  * Hash
    - AP ✔️
    - DJB2 ✔️
    - FNV0-32 ✔️
    - FNV0-64 ✔️
    - FNV1-32 ✔️
    - FNV1-64 ✔️
    - FNV1A-32 ✔️
    - FNV1A-64 ✔️
    - SDBM ✔️
    - SHA-1 ✔️ <span style="color:yellow">(wrapper only)</span>
    - SHA-2 (256 bits) ✔️ <span style="color:yellow">(wrapper only)</span>
    - MD2 ✔️ <span style="color:yellow">(wrapper only)</span>
    - MD5 ✔️ <span style="color:yellow">(wrapper only)</span>
    - (game-specific) Hercules (TODO) ❌
    - (game-specific) E-racer (TODO) ❌

  * Image
    - Decode RGB121 ✔️
    - Decode RGB121_BYTE ✔️
    - Decode RGBA2222 ✔️
    - Decode RGBX2222 ✔️
    - Decode GRAY8 ✔️
    - Decode RGBX332 (RGB8) ✔️
    - Decode BGRX332 (BGR8) ✔️
    - Decode/Encode RGB565 ✔️
    - Decode/Encode BGR565 ✔️
    - Decode RGBX5551 ✔️
    - Decode RGBA5551 ✔️
    - Decode RGB888 (RGB24) ✔️
    - Decode BGR888 (BGR24) ✔️
    - Decode ARGB4444 ✔️
    - Decode RGBA4444 ✔️
    - Decode ABGR4444 ✔️
    - Decode XBGR4444 ✔️
    - Decode RGBX4444 ✔️
    - Decode BGRA4444 ✔️
    - Decode BGRX4444 ✔️
    - Decode XRGB1555 ✔️
    - Decode ARGB1555 ✔️
    - Decode ABGR1555 ✔️
    - Decode XBGR1555 ✔️
    - Decode ARGB8888 ✔️
    - Decode ABGR8888 ✔️
    - Decode/Encode RGBA8888 ✔️
    - Decode/Encode BGRA8888 ✔️
    - Decode RGB48 ✔️
    - Decode BGR48 ✔️
    - Decode PAL4_RGBX5551 ✔️
    - Decode PAL4_BGRX5551 ✔️
    - Decode PAL4_XRGB1555 ✔️
    - Decode PAL4_XBGR1555 ✔️
    - Decode PAL4_RGB888 ✔️
    - Decode PAL4_BGR888 ✔️
    - Decode PAL4_IA8 ✔️
    - Decode PAL4_RGB565 ✔️
    - Decode PAL4_RGB5A3 ✔️
    - Decode PAL4_RGBA8888 ✔️
    - Decode PAL4_BGRA8888 ✔️
    - Decode PAL4_RGB5A3 ✔️
    - Decode PAL8_RGBX2222 ✔️
    - Decode PAL8_RGBX5551 ✔️
    - Decode PAL8_BGRX5551 ✔️
    - Decode PAL8_XRGB1555 ✔️
    - Decode PAL8_XBGR1555 ✔️
    - Decode PAL8_RGB888 ✔️
    - Decode PAL8_BGR888 ✔️
    - Decode PAL8_RGBX6666 ✔️
    - Decode PAL8_IA8 ✔️
    - Decode PAL8_RGB565 ✔️
    - Decode PAL8_RGB5A3 ✔️
    - Decode PAL8_RGBA8888 ✔️
    - Decode PAL8_BGRA8888 ✔️
    - Decode PAL16_IA8 ✔️
    - Decode PAL16_RGB565 ✔️
    - Decode PAL16_RGB5A3 ✔️
    - Decode N64_RGB5A3 ✔️
    - Decode N64_I4 ✔️
    - Decode N64_I8 ✔️
    - Decode N64_IA4 ✔️
    - Decode N64_IA8 ✔️
    - Decode N64_RGBA32 ✔️
    - Decode N64_CMPR ✔️
    - Decode BC1/DXT1 ✔️
    - Decode BC2/DXT3 ✔️
    - Decode BC3/DXT5 ✔️
    - Decode BC4 ✔️
    - Decode BC5 ✔️
    - Decode BC6 ✔️
    - Decode BC7 ✔️
    - Decode GST121 ✔️
    - Decode GST221 ✔️
    - Decode GST421 ✔️
    - Decode GST821 ✔️
    - Decode GST122 ✔️
    - Decode GST222 ✔️
    - Decode GST422 ✔️
    - Decode GST822 ✔️
    - Decode YUY2 ✔️
    - Decode NV12 ✔️
    - Decode NV21 ✔️
    - Decode UYVY ✔️
    - Decode YUV444P ✔️
    - Decode YUV410P ✔️
    - Decode YUV420P ✔️
    - Decode YUV422P ✔️
    - Decode YUV411P ✔️
    - Decode UYYVYY411 ✔️
    - Decode YUV440P ✔️
    - Decode YUVA420P ✔️
    - Decode AYUV ✔️
    - Decode GRAY8A (LA88) ✔️
    - Decode GRAY16 ✔️
    - Decode XRGB8888 ✔️
    - Decode RGBX8888 ✔️
    - Decode XBGR8888 ✔️
    - Decode BGRX8888 ✔️
    - Decode BUMPMAP_SR ✔️
    - 3DS Swizzling/Twiddling ✔️
    - CMPR Swizzling/Twiddling ✔️
    - PS2 Swizzling/Twiddling ✔️
    - PS2 Palette Swizzling/Twiddling ✔️
    - PS4 Swizzling/Twiddling ✔️
    - PSP Swizzling/Twiddling ✔️
    - PS Vita Swizzling/Twiddling ✔️
    - XBOX 360 Swizzling/Twiddling ✔️
    - GameCube/WII Swizzling/Twiddling ✔️
    - Switch Swizzling/Twiddling ✔️
    - XBOX/PS3 Swizzling/Twiddling (Morton Order) ✔️
    - Dreamcast Swizzling/Twiddling (Morton Order) ✔️
    - BC Swizzling/Twiddling ✔️
    - PS2 GS Texture Swizzling/Twiddling ✔️
    - PS2 GS Texture Compression ✔️

  * IO
    - File Reader ✔️
    - File Writer ✔️
    - Bytes Handler ✔️
    - Translation Text Handler ✔️
    - Mod Handler ✔️
    - File extension checking ✔️
    - Padding calculation ✔️
    - File size checking ✔️



  // CRC32 calculation
  ```
  from reversebox.crc import crc32_iso_hdlc
  from reversebox.common import common

  test_data = b'123456789'
  crc32_handler = crc32_iso_hdlc.CRC32Handler()
  crc32 = crc32_handler.calculate_crc32(test_data)
  print("CRC32_INT: ", crc32)
  print("CRC32_STR: ", common.convert_int_to_hex_string(crc32))
  ```
  // CRC32 output
  ```
  CRC32_INT:  3421780262
  CRC32_STR:  0xCBF43926
  ```




  // XOR Cipher (Basic)
  ```
  from reversebox.encryption.encryption_xor_basic import xor_cipher_basic


  test_data = b'abcd'
  test_key = b'\x3D'
  xor_result = xor_cipher_basic(test_data, test_key)
  print(xor_result)
  ```

  // XOR Cipher output
  ```
  b'\\_^Y'
  ```




  // File reading
  ```
  import os
  from reversebox.io_files.file_handler import FileHandler


  file_path = os.path.join(os.path.dirname(__file__), "file.bin")
  file_reader = FileHandler(file_path, "rb")
  file_reader.open()
  value = file_reader.read_str(4, "utf8")
  print(value)
  ```

  // File Reader Output
  ```
  ABCD
  ```




  // SHA-1 calculation
  ```
  from reversebox.hash.hash_sha1 import SHA1Handler

  test_data = b'abcd'
  sha1_handler = SHA1Handler()
  sha1 = sha1_handler.calculate_sha1_hash(test_data)
  print("SHA-1 hash: ", sha1)
  ```

  // SHA-1 Output
  ```
  SHA-1 hash:  b'\x81\xfe\x8b\xfe\x87Wl>\xcb"Bo\x8eW\x84s\x82\x91z\xcf'
  ```



  // DXT1 compressed image decoding

  ```
  from reversebox.image.image_decoder import ImageDecoder
  from reversebox.image.image_formats import ImageFormats
  from reversebox.image.pillow_wrapper import PillowWrapper


  def show_img():
      with open("image_data.bin", "rb") as f:
          image_data = f.read()

      img_width: int = 64
      img_height: int = 64
      decoder = ImageDecoder()
      wrapper = PillowWrapper()
      converted_data: bytes = decoder.decode_compressed_image(image_data, img_width, img_height, ImageFormats.DXT1)
      pil_image = wrapper.get_pillow_image_from_rgba8888_data(converted_data, img_width, img_height)
      pil_image.show()


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




  Need more examples? <br>
  Check out list of tools written using ReverseBox:
  - [Giana's Return ZDA Tool](https://github.com/bartlomiejduda/Tools/blob/master/NEW%20Tools/Gianas%20Return/Gianas_Return_ZDA_Tool.py)
  - [ObsCure 2 HVP Extractor](https://github.com/bartlomiejduda/Tools/blob/master/NEW%20Tools/ObsCure%202/ObsCure%202%20HVP%20Tools/Obscure_2_hvp_extractor.py)
  - [Tail Concerto Translation Tools](https://github.com/bartlomiejduda/Tools/tree/master/NEW%20Tools/Tail%20Concerto/Tail%20Concerto%20Tools)
  - [EA Graphics Manager](https://github.com/bartlomiejduda/EA-Graphics-Manager)
  - [Acclaim TRE Tool](https://github.com/bartlomiejduda/Tools/tree/master/NEW%20Tools/Acclaim/Acclaim_TRE_Tool)
  - [F-Zero X TEX Tool](https://github.com/bartlomiejduda/Tools/tree/master/NEW%20Tools/F-Zero%20X/TEX%20Tool)
  - [TPL Parser](https://github.com/bartlomiejduda/Tools/tree/master/NEW%20Tools/Mario%20Kart%20WII/TPL%20Parser)
  - [ImageHeat](https://github.com/bartlomiejduda/ImageHeat)
  - and more...


  ![PyPI Downloads](https://static.pepy.tech/badge/reversebox)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/ReverseBox)
  ![GitHub License](https://img.shields.io/github/license/bartlomiejduda/ReverseBox)
  ![GitHub commit activity](https://img.shields.io/github/commit-activity/y/bartlomiejduda/ReverseBox)
  ![GitHub repo size](https://img.shields.io/github/repo-size/bartlomiejduda/ReverseBox)
  ![PyPI - Version](https://img.shields.io/pypi/v/ReverseBox)


pkgId: 3fb3fe624c638510f86e6f4d8d07737b1dbe3f68c4fb7d3abd2abae9edab0ec4
name: python-S-Clustr-DSL-help
arch: noarch
version: 1.3.1
epoch: 0
release: 1
summary: Development documents and examples for S-Clustr-DSL
url: https://pypi.org/project/S-Clustr-DSL/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-S-Clustr-DSL-1.3.1-1.src.rpm
location_href: Packages/python-S-Clustr-DSL-help-1.3.1-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center" style="color: #00FF00; font-family: 'Lucida Console', Monaco, monospace; text-shadow: 2px 2px 10px #FF0000, 4px 4px 20px #000000; font-size: 3em;">
    S-Clustr (Shadow Cluster) Simple
  </h1>
  <p align="center">

    <img src="https://img.shields.io/badge/Python-3.9-darkblue" alt="Python-3.9" style="margin-right: 10px;">
    <img src="https://img.shields.io/badge/Tools-Hacker_tool-darkred" alt="Hacker_tool" style="margin-right: 10px;">
    <img src="https://img.shields.io/badge/Team-S--H4CK13-darkmagenta" alt="S-H4CK13" style="margin-right: 10px;">
    <img src="https://img.shields.io/badge/Threat-APT-darkorange" alt="APT" style="margin-right: 10px;">
    <img src="https://img.shields.io/badge/Category-IOT-darkgrey" alt="IOT" style="margin-right: 10px;">
    <img src="https://img.shields.io/badge/Category-OT-darkgrey" alt="OT" style="margin-right: 10px;">
    <img src="https://img.shields.io/badge/Category-IT-darkgrey" alt="IT" style="margin-right: 10px;">
    <img src="https://img.shields.io/badge/Threat-Botnet-darkred" alt="Botnet" style="margin-right: 10px;">
    <img src="https://img.shields.io/badge/Brand-Siemens(PLC)-darkblue" alt="Siemens-PLC" style="margin-right: 10px;">
  </p>




  This is a game plugin that maps the game visuals to real-world lighting, allowing for malicious control to complete the game.

  Start the game server:

  `$ python3 game.py`

  ![alt text](./pic/image_.png)

  Start the floor simulation client (if you are connecting to real devices, it must be a 5-column by 6-row building), input and connect to the shadow cluster server.

  ![alt text](./pic/image-2.png)

  `$ python3 scctest.py`

  ![alt text](./pic/image-1.png)

  Start the shadow cluster client and connect to the game server:

  `python3 S-Clustr_Client.py`
  `set rhost 192.168.0.109`
  `set key 038c97dac0397d783c078df6b6b07efb`
  `game 192.168.0.104 10011`

  ![alt text](./pic/image-3.png)

  After successfully connecting to the game server, the device will synchronize your game visuals in real time...
  Perhaps playing this game on a displayed building would be even more fun...



  ![alt text](./pic/image.png)





  `1. Write the pseudocode into the input box and compile it; a clustr package will be generated in the ./sccopt directory. `

  `2. Start the S-Clustr client and use the load command to execute the automation package. Example: load <key> <Path>`

  <img src="https://github.com/MartinxMax/MartinxMax/blob/main/Shadow.jpeg" alt="Description"/>



  | Type | Controlled Device | Wired | Wireless | 4G | Security Encryption | Protocol |
  | --- | ---- | --- | --- | --- | ---- | --- |
  | Embedded | Arduino | √ | × | √ | × | TCP/IP |
  | Embedded | Ai-Thinker AIR780E | × | × | √ | × | TCP/IP |
  | Embedded | ESP8266 | × | √ | × | × | TCP/IP |
  | Embedded | AT89C51 | × | × | √ | × | TCP/IP |
  | Embedded | STM32[103fc6t6] | × | × | √ | × | TCP/IP |
  | PLC | SIEMENS S7-1200 | √ | × | × | √ | TCP/IP |
  | PLC | SIEMENS S7-200 | √ | × | × | √ | TCP/IP |

  | Controlled PC Platform | Protocol | Security Encryption |
  | ------ | --- | ---- |
  | Windows | TCP/IP | Optional |
  | Linux | TCP/IP | Optional |
  | Mac OS | TCP/IP | Optional |

  | Server Files | Description |
  | ----- | --- |
  | S-Clustr_Server | Server |
  | S-Clustr_Client | Attacker Client |
  | DebugDevice | Simulates embedded device connecting to server |
  | Generate | One-click generation of embedded device programs |
  | Testpc | Windows host connecting to server |
  | blacklist.conf | Blacklist, marks IP groups that are prohibited from connecting |
  | Server.conf | Configuration parameters for the server |
  | Version.conf | Version information |
  | Linux_Installer.sh | Linux environment dependency installer |
  | Windows_Installer.bat | Windows environment dependency installer |
  | Parameter_Description-EN.xls | [English] Description of parameters in Server.conf |
  | Parameter_Description-ZH.xls | [Chinese] Description of parameters in Server.conf |










  1. Arduino UNO

  ![Arduino UNO](https://image.3001.net/images/20231003/1696319500_651bc80cd29c5e6f7d8d1.png!small)

  2. ENC28J60

  ![ENC28J60](https://image.3001.net/images/20231004/1696404809_651d15491408ad4740661.png!small)

  3. 1-channel Relay Module 5V

  ![Relay Module](https://image.3001.net/images/20231003/1696320112_651bca7049ff6d0cfd7c8.png!small)

  4. Dupont Wires

  ![Dupont Wires](https://image.3001.net/images/20231003/1696320323_651bcb43ea727fb6119ef.png!small)



  ![Wiring Diagram](https://image.3001.net/images/20231004/1696404864_651d15804a8adde1b9379.png!small)

  ![Wiring Diagram](https://image.3001.net/images/20231004/1696404881_651d1591885762a52c1a9.png!small)





  1. Arduino UNO

  ![Arduino UNO](https://image.3001.net/images/20231003/1696319500_651bc80cd29c5e6f7d8d1.png!small)

  2. SIM900A or SIM800A

  ![SIM900A](https://image.3001.net/images/20231003/1696320095_651bca5fdbb3a6a2b1941.png!small)

  3. 1-channel Relay Module 5V

  ![Relay Module](https://image.3001.net/images/20231003/1696320112_651bca7049ff6d0cfd7c8.png!small)

  4. Dupont Wires (Female to Female)

  ![Dupont Wires](https://image.3001.net/images/20231003/1696320323_651bcb43ea727fb6119ef.png!small)

  5. Mobile SIM Card

  *Mobile SIM is required because SIM800A and SIM900A support only 2G networks from Mobile, not Telecom or Unicom... However, the Airm2m AIR780e module should work with Unicom, so SIM series may not be needed as it is internally integrated.*

  ![Mobile SIM Card](https://image.3001.net/images/20231003/1696322442_651bd38a673737e609e44.png!small)



  Simulates controlling relay behavior upon receiving signal from Arduino.

  ![Wiring Diagram](https://image.3001.net/images/20231003/1696321543_651bd0070660a10028e00.png!small)

  ![Wiring Diagram](https://image.3001.net/images/20231003/1696321799_651bd107e606ad635d9d9.png!small)

  *Don’t know how to code?... Use Generate.py to generate Arduino code.*





  1. ESP8266

  ![ESP8266](https://image.3001.net/images/20231005/1696496352_651e7ae0eadb3f502abd5.png!small)

  2. 1-channel Relay Module 5V

  ![Relay Module](https://image.3001.net/images/20231003/1696320112_651bca7049ff6d0cfd7c8.png!small)

  3. Dupont Wires

  ![Dupont Wires](https://image.3001.net/images/20231003/1696320323_651bcb43ea727fb6119ef.png!small)



  ![Wiring Diagram](https://image.3001.net/images/20231005/1696496713_651e7c4961e1f66469f91.png!small)





  1. This development board has been tested and indeed is faster and more stable than the SIM series.
  2. Install Luatools: For programming.
  [https://doc.openluat.com/wiki/37?wiki_page_id=4489]



  1. Air780e Development Board

  *There is a SIM card slot on the back.*

  ![Air780e Development Board](https://image.3001.net/images/20231014/1697255772_652a115c4d9c45ee325b8.png!small)

  ![Air780e Development Board](https://image.3001.net/images/20231014/1697256035_652a1263e9098b9a5a733.png!small)

  2. 1-channel Relay Module 5V

  ![Relay Module](https://image.3001.net/images/20231003/1696320112_651bca7049ff6d0cfd7c8.png!small)

  3. Dupont Wires

  ![Dupont Wires](https://image.3001.net/images/20231003/1696320323_651bcb43ea727fb6119ef.png!small)



  ![Wiring Diagram](https://image.3001.net/images/20231014/1697256413_652a13ddced9ee29cc759.png!small)



  *Import the generated file into Luatools.*

  ![Import File](https://image.3001.net/images/20231014/1697256986_652a161a395cbe1d00004.png!small)

  *Select the core, provided in our Output\AIR780E\LuatOS-SoC_V1103_EC618.soc.*

  ![Select Core](https://image.3001.net/images/20231014/1697257233_652a1711a164adde8dc73.png!small)

  *Complete the programming according to the prompts. Note the three buttons on the board: Start, Reset, BOOT.*

  ![Buttons](https://image.3001.net/images/20231014/1697257441_652a17e10a6eb5ce11d70.png!small)





  1. 51 Microcontroller Minimal System Development Board with CH340 Downloader

  ![51 Microcontroller](https://image.3001.net/images/20231016/1697385869_652c0d8d827cba5a5f0b6.png!small)

  2. 1-channel Relay Module 5V

  ![Relay Module](https://image.3001.net/images/20231003/1696320112_651bca7049ff6d0cfd7c8.png!small)

  3. Dupont Wires (Female to Female)

  ![Dupont Wires](https://image.3001.net/images/20231003/1696320323_651bcb43ea727fb6119ef.png!small)

  4. SIM900A or SIM800A

  ![SIM900A](https://image.3001.net/images/20231003/1696320095_651bca5fdbb3a6a2b1941.png!small)

  5. Mobile SIM Card

  ![Mobile SIM Card](https://image.3001.net/images/20231003/1696322442_651bd38a673737e609e44.png!small)



  ![Wiring Diagram](https://image.3001.net/images/20231016/1697386548_652c1034eb77af75eea6b.png!small)






  Run the command:

  `python3 Generate.py`

  ![Generate.py](https://image.3001.net/images/20231016/1697386581_652c10555cac89556f026.png!small)

  *Fill in the parameters. Note that 127.0.0.1 is incorrect; you should enter the public IP address of the server, which is the IP of the machine running S-Clustr_Server.py.*

  ![Input Parameters](https://image.3001.net/images/20231003/1696321930_651bd18a964982b1d7c4d.png!small)

  *The output programming code will be located in the directory .\Device\Output\Model.*




  **Note:**
  1. The server must be on a public network. If your server is on a private network, you can consider port forwarding. The hacker's service defaults to port 9999, and the device service defaults to port 10000.
  2. The server and hacker client communicate with full encryption throughout. Encryption services are mandatory and cannot be disabled. Additionally, you can configure in the Server.conf file whether to provide encryption services when embedded devices or controlled PCs connect.
  3. For parameters in the Server.conf file that you do not understand, please refer to the detailed manual documentation.
  4. Each time the server starts, it generates a random 12-character key for authentication between the hacker and the controlled device to prevent unauthorized access by other hackers. You can manually specify the key (python3 S-Clustr_Server.py -keyh Maptnh -keyv Maptnh). Here, there are two keys for both the hacker and the controlled device: the first is a plaintext key, and if you find it too sensitive, you can use the subsequent temporary TOKEN as a key, which effectively prevents plaintext key exposure.

  ![Server Configuration](https://image.3001.net/images/20231003/1696323112_651bd6286aa926034bd61.png!small)
  *In this parameter, setting it to 1 enables encryption services for the controlled device, requiring the device to provide an authentication key for access; otherwise, access will be denied.*

  ![Server Configuration Detail](https://image.3001.net/images/20231003/1696323168_651bd6608c798de5fd12d.png!small)

  5. This setup effectively prevents man-in-the-middle (MITM) sniffing of communication packets between the hacker client and the server, further preventing replay attacks and decryption of encrypted data.



  `-lh`: Bind to a specified local IP address, default is 0.0.0.0
  `-lpv`: Set the local listening address for the device side, default port is 10000
  `-lph`: Set the local listening address for the hacker side, default port is 9999
  `-keyh`: Set the hacker side key, default is a randomly generated 12-character key
  `-keyv`: Set the device side key, default is a randomly generated 12-character key



  `python3 S-Clustr_Server.py`

  ![Server Running](https://image.3001.net/images/20231003/1696323448_651bd778647c82aa08cf5.png!small)




  **Note:**
  The client operates interactively, similar to the Metasploit penetration testing framework.



  After entering, type `help` or `?` or `options` to view the required settings:
  `set rhosts <IP>`: Set the IP address of the server
  `set rport <Port>`: Set the port of the server
  `set id <number>`: Select the ID number of the device to control, 0 means select all devices
  `set pwr <state>`: Control device status: Start [1], Stop [2], Query status [3]



  `python3 S-Clustr_Client.py`

  ![Hacker Client Screenshot](https://image.3001.net/images/20231003/1696323920_651bd950229e1881fffdc.png!small)

  *Query the current status of all devices*


  ```
  S-Clustr(V1.0.0)> set rhost 127.0.0.1
  [*] rhost => 127.0.0.1
  S-Clustr(V1.0.0)> set id 0
  [*] id => 0
  S-Clustr(V1.0.0)> set pwr 3
  [*] pwr => 3
  ```

  **PS:** You must provide the Key here, which determines whether you have permission to access the server. You can choose any key from the server.

  ![image.png](https://image.3001.net/images/20231003/1696324886_651bdd16be48fe704fe63.png!small)

  ```
  S-Clustr(V1.0.0)> set key cf5cdc4798a72283a4c0c0b1ef2ef5da
  [*] key => cf5cdc4798a72283a4c0c0b1ef2ef5da
  ```



  ```
  S-Clustr(V1.0.0)> set id 0
  [*] id => 0
  S-Clustr(V1.0.0)> set pwr 3
  [*] pwr => 3
  S-Clustr(V1.0.0)> run
  [*] Connecting to the server...
  [*] Attempting to authenticate to the server [127.0.0.1:9999]
  |   Device ID   |  Device Type  | Device State | Device Network |
  |:-------------:|:-------------:|:-------------:|:---------------:|
  |       1        |      None      |    Stopped     |   Disconnected   |
  |       2        |      None      |    Stopped     |   Disconnected   |
  |       3        |      None      |    Stopped     |   Disconnected   |
  |       4        |      None      |    Stopped     |   Disconnected   |
  |       5        |      None      |    Stopped     |   Disconnected   |
  |       6        |      None      |    Stopped     |   Disconnected   |
  |       7        |      None      |    Stopped     |   Disconnected   |
  |       8        |      None      |    Stopped     |   Disconnected   |
  |       9        |      None      |    Stopped     |   Disconnected   |
  |       10       |      None      |    Stopped     |   Disconnected   |
  |:-------------:|:-------------:|:-------------:|:---------------:|
  ```

  *We can see that the connection to the server was successful, and authentication was successful.*

  *If we set an incorrect Key, the server will not authorize you.*

  ![image.png](https://image.3001.net/images/20231003/1696325026_651bdda20a3ade75729c8.png!small)

  ![image.png](https://image.3001.net/images/20231003/1696325038_651bddae4348ef54a6219.png!small)

  *Simulating controlled devices connecting to the server and controlling all devices through the hacker client.*

  ![image.png](https://image.3001.net/images/20231003/1696325230_651bde6ea06aa09ce29dc.png!small)


  *All devices are online.*

  ![image.png](https://image.3001.net/images/20231003/1696325329_651bded1da4510ff2bf07.png!small)



  ```
  S-Clustr(V1.0.0)> set id 0
  [*] id => 0
  S-Clustr(V1.0.0)> set pwr 1
  [*] pwr => 1
  S-Clustr(V1.0.0)> run
  ```

  ![image.png](https://image.3001.net/images/20231003/1696325463_651bdf570f2bc9ff3a606.png!small)

  ![image.png](https://image.3001.net/images/20231003/1696325476_651bdf6439c9cef5bf0ab.png!small)



  ```
  S-Clustr(V1.0.0)> set id 0
  [*] id => 0
  S-Clustr(V1.0.0)> set pwr 2
  [*] pwr => 2
  S-Clustr(V1.0.0)> run
  ```

  ![image.png](https://image.3001.net/images/20231003/1696325887_651be0ff5a3bff29a4fc3.png!small)



  **Scenario:**

  After receiving the command, the controlled device should:
  1. Access the website `www.bing.com`.
  2. Open the calculator application.



  ![Image](https://image.3001.net/images/20231003/1696327337_651be6a9304ba513e44c1.png!small)

  Ensure that the correct key is entered for the controlled device.



  ![Image](https://image.3001.net/images/20231003/1696327393_651be6e18f1a83c55f71d.png!small)

  The device is successfully connected, and the hacker client has recognized it.



  The hacker client successfully queries the device and performs the desired actions.

  ![Image](https://image.3001.net/images/20231003/1696328517_651beb45dd05d703258bc.gif)



  For more information and detailed configuration parameters, refer to the following documents:

  - **[Parameter_Description-ZH.xls](link_to_document)**: Chinese version of the parameter description.

    ![Image](https://image.3001.net/images/20231003/1696326111_651be1dfb5a553110354d.png!small)

  - **[Parameter_Description-EN.xls](link_to_document)**: English version of the parameter description.

    ![Image](https://image.3001.net/images/20231003/1696326136_651be1f8121b3eaf709ac.png!small)


pkgId: 7ad21890118adb8833555854d821f97a74e9f6a7bc7f1b40df755d1bf392e360
name: python-SDL3-help
arch: noarch
version: 0.1.1b0
epoch: 0
release: 1
summary: Development documents and examples for SDL3
url: https://pypi.org/project/SDL3/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-SDL3-0.1.1b0-1.src.rpm
location_href: Packages/python-SDL3-help-0.1.1b0-1.noarch.rpm
checksum_type: sha256
description:
  This is an alias package for [PySDL3](https://github.com/Aermoss/PySDL3), please install [PySDL3](https://github.com/Aermoss/PySDL3) directly.


pkgId: 7dba40efbcde61ff0516d364614494aebd5c49e338fac6f506cd8101f5e38bbf
name: python-SMACT-help
arch: noarch
version: 3.0.1
epoch: 0
release: 1
summary: Development documents and examples for SMACT
url: https://github.com/WMD-group/SMACT
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-SMACT-3.0.1-1.src.rpm
location_href: Packages/python-SMACT-help-3.0.1-1.noarch.rpm
checksum_type: sha256
description:
  [![DOI](https://joss.theoj.org/papers/10.21105/joss.01361/status.svg)](https://doi.org/10.21105/joss.01361)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.5553202.svg)](https://doi.org/10.5281/zenodo.5553202)
  [![Documentation Status](https://readthedocs.org/projects/smact/badge/?version=latest)](http://smact.readthedocs.org/en/latest/?badge=latest)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  ![python version](https://img.shields.io/pypi/pyversions/smact)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![PyPi](https://img.shields.io/pypi/v/smact)](https://pypi.org/project/SMACT/)
  [![Conda](https://anaconda.org/conda-forge/smact/badges/version.svg)](https://anaconda.org/conda-forge/smact)
  [![GitHub issues](https://img.shields.io/github/issues-raw/WMD-Group/SMACT)](https://github.com/WMD-group/SMACT/issues)
  ![dependencies](https://img.shields.io/librariesio/release/pypi/smact)
  [![CI Status](https://github.com/WMD-group/SMACT/actions/workflows/ci.yml/badge.svg)](https://github.com/WMD-group/SMACT/actions/workflows/ci.yml)
  [![codecov](https://codecov.io/gh/WMD-group/SMACT/branch/master/graph/badge.svg?token=UtgVxjoYNP)](https://codecov.io/gh/WMD-group/SMACT)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/smact)



  **Semiconducting Materials from Analogy and Chemical Theory** (SMACT) is a collection of rapid screening and informatics tools that uses data about chemical elements.

  - **Documentation:** <https://smact.readthedocs.io/en/latest/>
  - **Examples:** <https://smact.readthedocs.io/en/latest/examples.html>

  ![A blue interface with the text "SMACT v3" at the top. Below that, there is a label "Materials Search" followed by two radio buttons: "Hi-fi" and "Lo-fi". The "Lo-fi" button is currently selected](SMACT.png)

  _If you torture the data enough, nature will always confess_ - Roland Coase (from 'How should economists choose?')



  There is a strong demand for functional materials across a wide range of technologies. The motivation can include cost reduction, performance enhancement, or to enable a new application. We have developed low-cost procedures for screening hypothetical materials. This framework can be used for simple calculations on your own computer. SMACT follows a top-down approach where a set of element combinations is generated and then screened using rapid chemical filters. It can be used as part of a multi-technique workflow or to feed artificial intelligence models for materials.

  ![A gif depicting using the SMACT code. The first lines of code show how SMACT can be used to access properties of Iron (Fe) by create an Fe Element object and then accessing the oxidation states, pauling electronegativity. The next line after these shows the use of the smact_filter function for the Fe-Cu-O chemical system followed by the lists of possible compositions. ](smact_simple.gif)



  Features are accessed through Python scripts, importing classes and functions as needed.
  The best place to start is looking at [the docs](https://smact.readthedocs.io/en/latest/), which highlight some simple examples of how these classes and functions can be usede
  Use cases are available in our [examples](https://smact.readthedocs.io/en/latest/examples.html) and [tutorials](https://smact.readthedocs.io/en/latest/tutorials.html) folders.



  - At the core of SMACT are [Element](https://smact.readthedocs.io/en/latest/smact.html#smact.Element) and [Species](https://smact.readthedocs.io/en/latest/smact.html#smact.Species) (element in a given oxidation state) classes that have various properties associated with them.

  - Oxidation states that are accessible to each element are included in their properties.

  - Element compositions can be screened through based on the heuristic filters of charge neutrality and electronegativity order. This is handled using the [screening module](https://smact.readthedocs.io/en/latest/smact.screening.html) and [this publication](<https://www.cell.com/chem/fulltext/S2451-9294(16)30155-3>) describes the underlying theory. An example procedure is [outlined in the docs](https://smact.readthedocs.io/en/latest/examples/filter.html).

  - Further filters can be applied to generated lists of compositions in order to screen for particular properties. These properties are either intrinsic properties of elements or are calculated for compositions using the [properties module](https://smact.readthedocs.io/en/latest/smact.properties.html). For example:

    - An application is shown in [this publication](https://pubs.rsc.org/en/content/articlehtml/2018/sc/c7sc03961a), in which 160,000 chemical compositions are screened based on optical band gap calculated using the [solid-state energy scale](https://www.sciencedirect.com/science/article/pii/S0022459615300888).
    - The [oxidation_states module](https://smact.readthedocs.io/en/latest/smact.oxidation_states.html) can be used to filter out compositions containing metals in unlikely oxidation states according to [a data-driven model](https://pubs.rsc.org/en/content/articlelanding/2018/fd/c8fd00032h#!divAbstract).

  - Compositions can also be filtered based on sustainability via the abundance of elements in the Earth's crust or via the [HHI scale](https://pubs.acs.org/doi/10.1021/cm400893e).

  - Compositions can be converted for use in Pymatgen or for representation to machine learning algorithms ([see this example](https://smact.readthedocs.io/en/latest/tutorials/smact_generation_of_solar_oxides.html)) and the related [ElementEmbeddings](https://github.com/WMD-group/ElementEmbeddings) package.

  - The code also has tools for manipulating common crystal lattice types:
    - Certain structure types can be built using the [builder module](https://smact.readthedocs.io/en/latest/smact.builder.html)
    - Lattice parameters can be estimated using ionic radii of the elements for various common crystal structure types using the [lattice_parameters module](https://smact.readthedocs.io/en/latest/smact.lattice_parameters.html).
    - The [lattice module](https://smact.readthedocs.io/en/latest/smact.lattice.html) and [distorter module](https://smact.readthedocs.io/en/latest/smact.distorter.html) rely on the [Atomic Simulation Environment](https://wiki.fysik.dtu.dk/ase/) and can be used to generate unique atomic substitutions on a given crystal structure.
    - The [structure prediction](https://smact.readthedocs.io/en/latest/smact.structure_prediction.html) module can be used to predict the structure of hypothetical compositions using species similarity measures.
    - The [dopant prediction](https://smact.readthedocs.io/en/latest/smact.dopant_prediction.html) module can be used to facilitate high-throughput predictions of p-type and n-type dopants of multicomponent solids.



  - **smact** library containing:
    - **\_\_init\_\_.py** Contains the core `Element` and `Species` classes.
    - **data_loader.py** Handles the loading of external data used to initialise the core `smact.Element` and `smact.Species` classes.
    - **screening.py** Used for generating and applying filters to compositional search spaces.
    - **properties.py** A collection of tools for estimating useful properties based on composition.
    - **lattice.py** Given the sites, multiplicities and possible oxidation states
      at those sites, this reads from the database and generates all possible
      stoichiometries.
    - **builder.py** Builds some common lattice structures, given the chemical
      composition.
    - **lattice_parameters.py** Estimation of lattice parameters for various lattice types using covalent/ionic radii.
    - **distorter.py** A collection of functions for enumerating and then
      substituting on inequivalent sites of a sub-lattice.
    - **oxidation_states.py**: Used for predicting the likelihood of species coexisting in a compound based on a statistical model.
    - **structure_prediction**: A submodule which contains a collection of tools for facilitating crystal structure predictions via ionic substitutions
    - **dopant_prediction**: A submodule which contains a collections of tools for predicting dopants.
    - **utils.py** A collection of utility functions used throughout the codebase.



  The main language is Python 3 and has been tested using Python 3.10+.
  Basic requirements are Numpy and Scipy.
  The [Atomic Simulation Environment](https://wiki.fysik.dtu.dk/ase) (ASE), [spglib](http://atztogo.github.io/spglib), and [pymatgen](https://pymatgen.org) are also required for many components.



  The latest stable release can be installed via pip which will automatically set up other Python packages as required:

      pip install smact

  Optional dependencies can also be installed. These enable full replication of the examples and tutorials

      pip install "smact[optional]"

  SMACT is also available via conda through the conda-forge channel on Anaconda Cloud:

      conda install -c conda-forge smact

  Alternatively, the very latest version can be installed using:

      pip install git+https://github.com/WMD-group/SMACT.git

  For developer installation SMACT can be installed from a copy of the source
  repository (<https://github.com/wmd-group/smact>); this will be preferred if using experimental code branches.

  To clone the project from GitHub and make a local installation:

      git clone https://github.com/wmd-group/smact.git
      cd smact
      pip install --user -e .

  With -e pip will create links to the source folder so that that changes
  to the code will be immediately reflected on the PATH.



  Python code and original data tables are licensed under the MIT License.





  Please use the [Issue Tracker](https://github.com/WMD-group/smact/issues) to report bugs or request features in the first instance. While we hope that most questions can be answered by searching [the docs](https://smact.readthedocs.io/en/latest/), we welcome new questions on the issue tracker, especially if they helps us improve the docs! For other queries about any aspect of the code, please contact Anthony Onwuli (maintainer) by [e-mail](mailto:anthony.onwuli16@imperial.ac.uk).



  We are always looking for ways to make SMACT better and more useful to the wider community; contributions are welcome. Please use the ["Fork and Pull"](https://guides.github.com/activities/forking/) workflow to make contributions and stick as closely as possible to the following:

  - Code style should comply with [PEP8](http://www.python.org/dev/peps/pep-0008) where possible. [Google's house style](https://google.github.io/styleguide/pyguide.html) is also helpful, including a good model for docstrings.
  - Please use comments liberally when adding nontrivial features, and take the chance to clean up other people's code while looking at it.
  - Add tests wherever possible, and use the test suite to check if you broke anything.
  - Look at the [contributing guide](CONTRIBUTING.md) for more information.



  We use integrated testing on GitHub via [GitHub Actions](https://github.com/features/actions). Testing modules should be pass/fail and wrapped into **tests/test_core.py** or another **tests/test_something.py** file added, if appropriate.
  Run the tests using `python -m pytest -v`.(The final `-v` is optional and adds more detail to the output.)



  [H. Park et al.,
  "Mapping inorganic crystal chemical space" _Faraday Discuss._ (2024)](https://pubs.rsc.org/en/content/articlelanding/2024/fd/d4fd00063c)

  [D. W. Davies et al.,
  "SMACT: Semiconducting Materials by Analogy and Chemical Theory" _JOSS_ **4**, 1361 (2019)](https://joss.theoj.org/papers/7efd2f2ad60d25bdccee3fbd3fc11448)

  [D. W. Davies et al.,
  "Materials discovery by chemical analogy: role of oxidation states in structure prediction" _Faraday Discuss._ **211**, 553 (2018)](https://pubs.rsc.org/en/Content/ArticleLanding/2018/FD/C8FD00032H)

  [D. W. Davies et al.,
  "Computational screening of all stoichiometric inorganic materials" _Chem_ **1**, 617 (2016)](<http://www.cell.com/chem/abstract/S2451-9294(16)30155-3>)

  [B. R. Pamplin, "A systematic method of deriving new semiconducting compounds by structural analogy", _J. Phys. Chem. Solids_
  **25**, 675 (1964)](http://www.sciencedirect.com/science/article/pii/0022369764901763)


