semvec/pypi-packages huggingface dataset:
cyclehunter 0.0.4
Framework for Discrete Nonlinear Dynamics and Chaos
Requires Python: >=3.8
Keywords: pde,partial differential equation,numeric,numerical simulation,solver,framework,periodic cycle

# Cyclehunter

## Introduction

This package/repository is a organizational effort to manage a collection of Physics research projects associated
with the Center of Nonlinear Dynamics and Chaos at Georgia Tech and their collaborators. The sister Python package,
orbithunter, was mainly concerned with solving differential algebraic equations associated with finding spatiotemporal
solutions to partial differential equations. 

In this case, we are concerned with counting of prime cycles of discrete mappings such as Arnold's cat map, phi-k scalar
field theory, etc. where the systems are simple enough to enable analytic counting formulae and well founded symbolic
alphabets. Because of this, the overhead to find individual cycles is greatly diminished; the main hurdle is instead to
enumerate the entire set of prime cycles for usage in cycle expansion equations / dynamical zeta functions. "Prime"
denotes the set of cycles which remain after quotienting all symmetries, i.e. the unique cycles.

Therefore, the focus is much less on singular/individual cycles, rather, entire collections of prime cycles. Numerically
this is a different challenge and makes much more sense to solve the problem *en masse* because cycles of a specified 
length $n$ are easy to enumerate, can be solved for simultaneously and in parallel. The object oriented programming
which results from this is one in which the custom class objects will represent *all* cycles at once. 

You can install the python environment by downloading a python distribution (go to python.org).

I highly recommend you create a virtual environment as well; so do one of the following
in command line terminal


```
pip install -r requirements.txt
```

or

(note the periods; they are necessary)

Make a folder, copy the requirements.txt file into it, then type these commands; this
assumes your python.exe is in your terminal path. 

```
python -m venv .
cd Scripts
./activate
cd ..
pip install -r requirements.txt
```
ga-api-client-uf018127 0.2.4
GenieAnalytics API client
Requires Python: >=3.9

# GenieAnalytics Python Client

This package is the official Python client to access GenieAnalytics API server.

## Installation

```
pip install ga-api-client-uf018127
```

## Import Modules

```python
from ga_api import Repository, HyperLogLog
```

## Top Level Pattern

```python
from ga_api import Repository, System, HyperLogLog
import asyncio
import pandas as pd

async def main():
    try:
        repo = Repository('https://rdlab-214.genie-analytics.com/api', 'api', 'default', 'api123!@#')
        # ...
        # access API server to do whatever you need
        # ...
    finally:
        await repo.close()

if __name__ == '__main__':
    asyncio.run(main())
```
searchlights 0.2.0
A collection of pre-computed searchlights.
Requires Python: >=3.6
Keywords: brain,surface,fmri,mvpa,searchlight,searchlight-analysis

[![codecov](https://codecov.io/gh/feilong/searchlights/branch/main/graph/badge.svg?token=A3W4ZK1RAM)](https://codecov.io/gh/feilong/searchlights)
[![PyPI](https://img.shields.io/pypi/v/searchlights)](https://pypi.org/project/searchlights/)
[![PyPI - Downloads](https://img.shields.io/pypi/dm/searchlights)](https://pypistats.org/packages/searchlights)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/searchlights)

`searchlights` is a Python package that provides precomputed searchlights for surface-based analysis of fMRI data.
It only depends on `NumPy`.

## Installation
The package can be installed with pip:
```bash
python -m pip install searchlights
```

## Example usage

The surface-based fMRI data we usually use (e.g., [Feilong et al., 2018](https://doi.org/10.1016/j.neuroimage.2018.08.029)) are in `fsaverage` space, downsampled to a lower resolution (`icoorder5`, approximately 3 mm vertex spacing).
The surface has 9372 vertices for the left hemisphere, and 9370 vertices for the right hemisphere.
The code below shows how to get the searchlights for the left hemisphere with a 20 mm radius.

```python
import numpy as np
from searchlights import get_searchlights
sls = get_searchlights('l', 20, 'fsaverage')
```

See the [documentation](https://feilong.github.io/searchlights/#example) for more examples and details.
keyauth 1.0.3
Keyauth.win API Wrapper for python3



---------------------------------------
# Keyauth API Wrapper  
- KeyAuth is an Open-source authentication system with cloud-hosted subscriptions available as well.

---------------------------------------

# Installation
```bash
pip3 install keyauth
```

# Usage
```python
import pwinput
from keyauth import *

client = Keyauth(
    name="application name",
    owner_id="your account id",
    secret="application secret",
    version="current version",
    file_hash=misc.get_checksum()
)

print(client.application)
print("Validation status: %s" % (client.check()))
print("Blacklist status: %s" % (client.check_blacklist()))

print()

print("1=login; 2=register; 3=upgrade, 4=license key")
option = int(input("Option: "))

if option == 1:
    reply = client.login(
        username=input("Username: "),
        password=pwinput.pwinput("Password: ")
    )
if option == 2:
    reply = client.register(
        username=input("Username: "),
        password=pwinput.pwinput("Password: "),
        license_key=pwinput.pwinput("License: ")
    )
if option == 3:
    reply = client.upgrade(
        username=input("Username: "),
        license_key=pwinput.pwinput("License: ")
    )
if option == 4:
    reply = client.license(
        license_key=pwinput.pwinput("License: ")
    )

print(client.user)
```