semvec/pypi-packages huggingface dataset:
partricol 0.0.5.3
Package collected during my work with PARSEC-TRILEGAL-COLIBRI
Requires Python: >=3.6

# PARTRICOL

## making this pkg available on pypi
0. install some tools, once for all
```
python3 -m pip install --user --upgrade setuptools wheel twine
```
1. generate the package for uploading
```
python3 setup.py sdist bdist_wheel
```
change the version number every time for new versions in the `setup.py`

2. upload the package
```
twine upload --repository-url https://upload.pypi.org/legacy/ dist/partricol-0.0.X.tar.gz
```
Replace 'X' witht the correct version number. The 0.0.1 was deleted (I tried to remove the project), and it will never come back...

You can also upload to the testpy first for checking if everything fine:
```
twine upload --repository testpypi dist/partricol-0.0.X.tar.gz
```

## installation
```
pip install --user partricol
```

## update
```
pip install partricol --upgrade --user
```

## Usage

### cypar: reading mine-style parameter files
The original package is at https://pypi.org/project/cypar/
```
from partricol import cypar
test=cypar.read('test.par')
```

### def_par_trilegal and write_par_trilegal
```
from partricol import tripar
test1=tripar.def_par_trilegal()
print(test1.tri.output_kind)
   #to change the values

tripar.write_par_trilegal(test1.cmd, 'cmd.par', test1.tri, 'tri.par') #which writes 'cmd.par' and 'tri.par'
```

### run_trilegal
```
from partricol import tripar
tripar.run_trilegal('S_002_phat_regions_M08.par','./main','.fits')
```
where `./main` is the trilegal executable.

### colibri2trilegal
```
from partricol.colibri2trilegal.colibri2trilegal_cycy_noeagb import colibri2trilegal
#besides colibri2trilegal_cycy_noeagb the other options are colibri2trilegal_phil, colibri2trilegal_cycy_eagb, colibri2trilegal_cycy_noeagb_fake
from partricol.colibri2trilegal.def_par_colibri2trilegal import def_par_colibri2trilegal
from partricol.colibri2trilegal.write_par_colibri2trilegal import write_par_colibri2trilegal
s=def_par_colibri2trilegal()

   #to change the values

write_par_colibri2trilegal(s,'test.inp')
colibri2trilegal('test.inp')
```


### parcol
```
from partricol import parcol
parcol.parcol(exe="../isotracks/code/revisegrid/main",parsec_dbert_dir="../isotracks/isotrack_parsec/CAF09_V1.2S_M36_S12D_NS_MAS3/dbert_comp",inpdir="./INP",indir="./S_035",outdir="isotrack_parcol/CAF09_V1.2S_M36_S12D_NS_MAS3/dbert_comp035",outfile="isotrack_parcol/CAF09_V1.2S_M36_S12D_NS_MAS3_parcol_comp035.dat")
```


### match2trilegal
```
from match2trilegal import process_match_sfh, process_match_popbox
sfr_match=glob.glob(os.path.join(sfr_dir,region,'region_'+region+'.optir'+quartile+'_*.popbox'))
process_match_popbox(sfr_match, outfile=sfr_tri)
```
sphinx-autopackagesummary 1.3
Sphinx extension to automatically generate autosummary tables for Python packages
Requires Python: >= 3.4

sphinx-autopackagesummary
=========================

This is a [Sphinx](https://www.sphinx-doc.org/) extension that makes it
possible to automatically generate API documentation for deeply nested Python
packages using the built-in autosummary extension.

The problem with the built-in autosummary directive is that it does not
automatically pick up nested sub-modules, requiring tedious manual work to
specify the entire module tree.

Instead of this:

```rst
.. autosummary::
   :toctree: _autosummary

   mypackage.submodule1
   mypackage.submodule2
   mypackage.submodule3
```

You can now simply use this:

```rst
.. autopackagesummary:: mypackage
   :toctree: _autosummary
```

Usage
-----

To make use of this extension, the following steps are needed:

1. Install the module using pip.
```
pip install sphinx-autopackagesummary
```
2. Enable it in `conf.py`.
```python
extensions = ['sphinx.ext.autosummary', 'sphinx_autopackagesummary']

autosummary_generate = True
```
3. Make use of the new syntax

Configuration
-------------

The `autopackagesummary` directive accepts all options that are supported by
`autosummary`, which are simply passed on.

To exclude packages from being imported, add them to the config setting
`autosummary_mock_imports`.

Recursive generation
--------------------

If your packages have subpackages, it is possible to use this recursively by
customizing the autosummary template.  For example, you could have your root
package documented like so:
```rst
.. py:package:: mypackage

   This is my package.

   .. autopackagesummary:: mypackage
      :toctree: _autosummary
      :template: autosummary/package.rst
```

And then create a `_templates/autosummary/package.rst` like so:

```rst
{{ fullname | escape | underline }}

.. automodule:: {{ fullname }}

   .. autopackagesummary:: {{ fullname }}
      :toctree: .
      :template: autosummary/package.rst
```

Alternatively, you can override the default `module.rst` template.

Note the use of `.` for the toctree setting: otherwise, the `_autosummary`
directories would keep nesting, like `_autosummary/_autosummary/module.rst`.

License
-------

This extension has been placed into the public domain.  If you make a
contribution to this repository, you are placing your modifications into the
public domain as well.
heliPypter 0.0.7
A package for rotorcraft performance evaluation.
Requires Python: >=3.6

# helipypter

![alt text](docs/img/banner.png "helipypter")

heliPypter is a package for rotorcraft performance evaluation. Rotorcraft attributes are provided as input, 
and performance characteristics such as Engine Horsepower, Specific Range, and Fuel consumption are evaluated.

heliPypter has an object oriented philosophy, so different rotorcraft configurations can be built, modified,
and evaluated quickly, with the same methods. The classes have methods for Hover in and out of Ground Effect
(HOGE and HIGE), as well as forward flight.

Under the hood, briefly speaking, the code applies Momentum Theory assuming constant chord ideal twist.
Correction factors can be supplied to align results with tapered, linearly twisted blades. For forward flight, 
Glauert's Model is used.

## Installation:

For most sytems, the easiest way to install this package is through the Python Package Index:

```
$ pip install helipypter
```

## Documentation

This package has full documentation on [readTheDocs](https://helipypter.readthedocs.io/). The 'API' page is fully documented and shows
what different members of each class are, and what methods are available. The entire documentation will be
expanded as the package is developed.


Like this package or my work? Feel free to [buy me a coffee](https://www.buymeacoffee.com/czarified).
All donations will be used as developer fuel!


#### Attributions

Huey Graphic by Jetijones - Own work, CC BY 3.0, https://commons.wikimedia.org/w/index.php?curid=15743299

Blade Element graphic by Smilesgiles89 - MS Paint, CC BY-SA 3.0, https://en.wikipedia.org/w/index.php?curid=38336902
pygithubutils 1.0.2
Manage large 1..1000 user teams for classroom and insitutions with GitHub API calls.
Requires Python: >=3.6
Keywords: git,GitHub

# PyGitHub Utilities

![Actions Status](https://github.com/scivision/pygithub-utils/workflows/ci/badge.svg)

GitHub API utilities for managing large numbers (10..1000) of users and repositories for education and institutions.
GitHub v3 API is used via actively developed and growing
[PyGitHub](https://pypi.org/project/PyGithub/).
For very large number of repos say 1000+, it may be more useful and fast to use the GraphQL GitHub v4 API.
Input / output is often via spreadsheet, as a gateway to APIs of other services such as Blackboard.

This repository helps us avoid having to use
[GitHub Education](https://education.github.com/).

For example:

* create repo for each team project (CreateGithubTeamRepos.py)
* mass-add per-project collaborators (AddGithubCollab.py)
* duplicate (mirror) lots of repos (DuplicateGithubRepos.p)

We also maintain Python-based Git
[utilities](https://github.com/scivision/gitutils).

An important feature in

```sh
python CountGithubForks.py username
```
is showing which forks of your repos have had changes "ahead of" the parent repo.

---

Count how many total GitHub stars a GitHub account has:

```sh
python CountGithubStars.py username
```

That will take a couple seconds even for large numbers of repos.


## Mass duplicate GitHub repos

`DuplicateGithubRepos`
based on spreadsheet input, mass duplicate GitHub repos.

## API Key

Users will need a GitHub API token, as the unauthenticated API access is severely limited.

1. [Generate](https://github.com/settings/tokens) GitHub API token with permission appropriate to the PyGitHub Utilities script being used.
2. Copy that text string to a secure location on your computer.

### permissions

For public repos, "public_repo" is needed.
For private repos, "repo" is needed.

"admin:org" Oauth does not work.

It's suggested you create an Oauth key for this, and then disable/delete this key permissions when done
to avoid a security issue.
To do this, including for Organizations, go to your
Username, Settings, Developer Settings, Personal Access Tokens and set repo:public_repo.
For organization private repos, you need "repo" permissions on the Oauth token.

if you get error

```
github.GithubException.UnknownObjectException: 404 {'message': 'Not Found',
'documentation_url': 'https://developer.github.com/v3/repos/#edit'}
```

that typically means your Oauth key doesn't have adequate permissions.
NasNas 0.1.3
A simple game framework to get started quickly with python and sfml.
Keywords: sfml,game dev,game engine,framework

# pyNasNas
### A simple game framework to get started quickly with python and sfml.

### Features :
 - [x] Automatic resource loader and  manager system
 - [x] Scene and Layers system
 - [x] Entities, sprites and animations 
 - [x] Cameras
 - [x] Text and bitmap fonts
 - [x] Tiled map loader (.tmx)
 - [x] Debug text display in-game
 - [x] Transitions

### In progress :
 - [x] Menus and UI

### To do :
 - [ ] Splash screens
 - [ ] Levels and game events management
 - [ ] In-game command line for debugging
 - [ ] Particles system


### Install

#### From pip
``` 
python3 -m pip install NasNas
```
Then you can import NasNas anywhere in your projects
```python
import NasNas as ns
```

#### From source
Download and extract the repository. Then run 
```
python3 setup.py install
```

#### Local install
Let's say your project has the following structure
```
YourProject
    |_ assets
    |_ src
    main.py
```

Download the repository and copy the NasNas folder into your project src folder.
```
YourProject
    |_ assets
    |_ src
        |_ NasNas
    main.py
```
Then you can, import NasNas with:
 ```python 
import src.NasNas as ns
```

### Get started

Visit the [wiki](https://github.com/Madour/pySFMLGameEngine/wiki) to get started.

You can also take a look at the example project to see how to use it.

Be sure to run run_example.py from example folder like this : `python3 ../run_example.py`

### Other

A C++ version of NasNas is under development, you can check it out [here](https://github.com/Madour/NasNas)

### Author

 - Modar Nasser
pepephone-data 1.0.5
Shows Pepephone used and available data
Requires Python: >=3.6

![Pypi](https://img.shields.io/pypi/v/pepephone-data)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

# pepephone-data
English Below

## Castellano
`pepephone-data` es una manera rápida para ver el uso de datos si usas Pepephone: sin tener que hacer login en la Web / aplicación móvil desde la línea de comandos.

Se necesita crear un fichero en uno de los sitios:
```
$HOME/.pepephone
/etc/pepephone
```

Con este contenido:

```
[authentication]
email = email_used_to_authenticate_on_pepephone.com
password = password_for_your_pepephone_account
phone = your_pepephone_phone_number

[extra]
extra_GB = 25
```

El estra es opcional: en este caso añade 25 GB a los datos disponibles de Pepephone. La razón: si planeas añadir datos pero no lo has hecho aún.

Ejemplo:
```
Time         : 2020-05-10 16:37:02
GB total     : 75.58 GB (Including extra 25 GB)

GB used total: 17.93 GB (EU roaming: 0.00 GB)
GB used/day  : 1.79 GB/day

GB remaining : 57.65 GB
GB remain/day: 2.62 GB/day

% Used       : 23.72%
% Month      : 32.26%
```
El `GB total` incluye los datos acumulados del mes pasados, regalos de Pepephone, etc.

## English
`pepephone-data` is a quick way to check usage data of Pepephone: without Web or mobile application from the command line.

Create a file in one of the places:
```
$HOME/.pepephone
/etc/pepephone
```

With this contents:
```
[authentication]
email = email_used_to_authenticate_on_pepephone.com
password = password_for_your_pepephone_account
phone = your_pepephone_phone_number

[extra]
extra_GB = 25
```
The extra is optional: in this case it will add 25 GB to the data available on Pepephone. The reason: you might plan to add 25 GB during the month but not have done it yet.

Execute `show-data-used.py`:
```
Time         : 2020-05-10 16:37:02
GB total     : 75.58 GB (Including extra 25 GB)

GB used total: 17.93 GB (EU roaming: 0.00 GB)
GB used/day  : 1.79 GB/day

GB remaining : 57.65 GB
GB remain/day: 2.62 GB/day

% Used       : 23.72%
% Month      : 32.26%
```

The GB total includes last months remaining data, Pepephone "gifts", etc.