semvec/pypi-packages huggingface dataset:
Kompy 0.0.12
A Python wrapper for Komoot APIs
Requires Python: >=3.11

# Kompy

![example workflow](https://github.com/tsadoq/kompy/actions/workflows/python-app.yml/badge.svg)

## Overview

Kompy is a wrapper for [Komoot APIs](https://static.komoot.de/doc/external-api/v007/index.html) that allows you to
download and upload your activities from Komoot.

A documentation can be found [here](https://tsadoq.github.io/kompy/).

## Features

- **Download Activities from Komoot**: Download your activities from Komoot to GPX, FIT or Custom Object format.
- **Upload Activities to Komoot**: Upload your activities to Komoot from GPX, FIT files.
- **Download Tours from Komoot**: Download your tours from Komoot
- **Change Activities on Komoot**: Change activity type or name of your existing activity on Komoot
- **Delete Activities on Komoot**: Delete your existing activity on Komoot

## Installation

To get started with the Kompy, follow these steps:

1. Ensure you have Python installed on your system. This app is compatible with Python 3.11 and above.

2. pip the package:

    ```bash
    pip install kompy
    ```
3. Import the package to your project:
    ```python
   import kompy as kp
    ```

## Usage

For a more detailed usage example, please
check [this notebook](https://github.com/Tsadoq/kompy/blob/main/examples/run_kompy.ipynb).

The most basic usage is:

1. Create a connector:
    ```python
   from kompy import KomootConnector
   connector = KomootConnector(password=..., email=...)
    ```
2. Fetch your activities:
    ```python
   tours_list = connector.get_tours(user_identifier=None)
    ```

## Run the tests

To run the tests (locally), run:

```bash
  pytest .
```

or
```bash
  python -m unittest
```

## Contributing

Contributions to Kompy are welcome! If you have a suggestion that would make this app better, please fork the repo
and create a pull request. You can also simply open an issue with the tag "enhancement".

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

## Acknowledgements

- [Requests](https://docs.python-requests.org/en/latest/)
- [Python Imaging Library (PIL)](https://python-pillow.org/)
- [gpxpy](https://github.com/tkrajina/gpxpy)
- [FIT](https://pypi.org/project/fit-tool/)
PyNN 0.12.4
A Python package for simulator-independent specification of neuronal network models
Requires Python: >=3.9
Keywords: computational neuroscience, simulation, neuron, nest, brian2, neuromorphic

PyNN
====

PyNN (pronounced '*pine*') is a simulator-independent language for building
neuronal network models.

In other words, you can write the code for a model once, using the PyNN API and
the Python programming language, and then run it without modification on any
simulator that PyNN supports (currently NEURON, NEST and Brian 2) and
on a number of neuromorphic hardware systems.

The PyNN API aims to support modelling at a high-level of abstraction
(populations of neurons, layers, columns and the connections between them) while
still allowing access to the details of individual neurons and synapses when
required. PyNN provides a library of standard neuron, synapse and synaptic
plasticity models, which have been verified to work the same on the different
supported simulators. PyNN also provides a set of commonly-used connectivity
algorithms (e.g. all-to-all, random, distance-dependent, small-world) but makes
it easy to provide your own connectivity in a simulator-independent way.

Even if you don't wish to run simulations on multiple simulators, you may
benefit from writing your simulation code using PyNN's powerful, high-level
interface. In this case, you can use any neuron or synapse model supported by
your simulator, and are not restricted to the standard models.


- Home page: http://neuralensemble.org/PyNN/
- Documentation: http://neuralensemble.org/docs/PyNN/
- Mailing list: https://groups.google.com/forum/?fromgroups#!forum/neuralensemble
- Bug reports: https://github.com/NeuralEnsemble/PyNN/issues


:copyright: Copyright 2006-2024 by the PyNN team, see AUTHORS.
:license: CeCILL, see LICENSE for details.

.. image:: https://github.com/NeuralEnsemble/PyNN/actions/workflows/full-test.yml/badge.svg
   :target: https://github.com/NeuralEnsemble/PyNN/actions/workflows/full-test.yml
   :alt: Unit Test Status

.. image:: https://coveralls.io/repos/NeuralEnsemble/PyNN/badge.svg?branch=master&service=github
   :target: https://coveralls.io/github/NeuralEnsemble/PyNN?branch=master
   :alt: Test coverage

Funding
-------

Development of PyNN has been partially funded by the European Union Sixth Framework Program (FP6) under
grant agreement FETPI-015879 (FACETS), by the European Union Seventh Framework Program (FP7/2007­-2013)
under grant agreements no. 269921 (BrainScaleS) and no. 604102 (HBP),
and by the European Union’s Horizon 2020 Framework Programme for
Research and Innovation under the Specific Grant Agreements No. 720270 (Human Brain Project SGA1)
, No. 785907 (Human Brain Project SGA2) and No. 945539 (Human Brain Project SGA3).
autopip-Ninja-22 0.9
Python modüllerini otomatik yükleyen kütüphane
Requires Python: >=3.6

# AutoPIP

Python modÃ¼llerini otomatik yÃ¼kleyen kÃ¼tÃ¼phane. Import edilen modÃ¼ller eksikse otomatik olarak pip ile yÃ¼kleme yapar.

## Kurulum

```bash
pip install autopip-Ninja-22
```

## KullanÄ±m

Ä°ki farklÄ± kullanÄ±m ÅŸekli var:

1. Kod Ã§alÄ±ÅŸÄ±rken otomatik yÃ¼kleme:
```python
import autopip
autopip.watch()  # Bu satÄ±rÄ± kodunuzun baÅŸÄ±na ekleyin

# ArtÄ±k eksik modÃ¼ller otomatik yÃ¼klenecek
import pandas  # pandas yÃ¼klÃ¼ deÄŸilse otomatik yÃ¼klenir
```

2. Belirli bir kod parÃ§asÄ± iÃ§in yÃ¼kleme:
```python
import autopip

kod = """
import pandas
import numpy
"""

# Eksik modÃ¼lleri yÃ¼kle
yuklenenler = autopip.auto_install(kod)
print("YÃ¼klenen modÃ¼ller:", yuklenenler)
```

## Ã–zellikler

- Python kodundaki import ifadelerini otomatik tespit eder
- Eksik modÃ¼lleri pip ile otomatik yÃ¼kler
- Standart kÃ¼tÃ¼phane modÃ¼llerini yÃ¼klemeye Ã§alÄ±ÅŸmaz
- Ä°ki farklÄ± kullanÄ±m modu (watch ve auto_install)

## Lisans

MIT License
docketanalyzer-ocr 0.1.9
Docket Analyzer OCR Utility
Requires Python: >=3.10

# Docket Analyzer OCR

## Installation

```bash
pip install 'docketanalyzer[ocr]'
```

## Local Usage

Process a document:

```python
from docketanalyzer.ocr import pdf_document

path = 'path/to/doc.pdf
doc = pdf_document(path) # the input can also be raw bytes
doc.process()

for page in doc:
    for block in page:
        for line in block:
            pass
```

You can also stream pages as they are processed:

```python
doc = pdf_document(path)

for page in doc.stream():
    print(page.text)
```

Pages, blocks, and lines have common attributes:

```python
# where item is a page, block, or line

item.data # A dictionary representation of the item and it's children
item.text # The item's text content
item.page_num # The page the item appears on
item.i # The item-level index
item.id # A unique id constructed from the item and it's parents index (e.g. 3-2-1 for the first line in the second block on the third page).
item.bbox # Bounding box (blocks and lines only)
item.clip() # Extract element as an image from the original pdf
```

Blocks also have a block type attribute:

```python
print(block.block_type) # 'title', 'text', 'figure', etc.
```

Save and load data:

```python
# Saving a document
doc.save('doc.json')

# Loading a document
doc = pdf_document(path, load='doc.json')
```

# Remote Usage

You can also serve this tool with Docker.

```bash
docker pull nadahlberg/docketanalyzer-ocr:latest
docker run --gpus all -p 8000:8000 nadahlberg/docketanalyzer-ocr:latest
```

And then use process the document in remote mode:

```python
doc = pdf_document(path, remote=True) # pass endpoint_url if not using localhost

for page in doc.stream():
    print(page.text)
```

# S3 Support

When using the remote service, if you want to avoid sending the file in a POST request, configure your S3 credentials. Your document will be temporarily pushed to your bucket to be retrieved by the service.

To configure your S3 credentials run:

```
da configure s3
```

Or set the following in your env:

```
AWS_ACCESS_KEY_ID
AWS_SECRET_ACCESS_KEY
AWS_S3_BUCKET_NAME
AWS_S3_ENDPOINT_URL
```

Usage is identical. We default to using S3 if credentials are available. You can control this explicitly by passing `use_s3=False` to `pdf_document`.

# Serverless Support

For serverless usage you can deploy this to RunPod. To get set up:

1. Create a serverless worker on RunPod using the docker container.

```bash
nadahlberg/docketanalyzer-ocr:latest
```

2. Add the following custom run command.

```
python -u handler.py
```

3. Add your S3 credentials to the RunPod worker.

```
AWS_ACCESS_KEY_ID
AWS_SECRET_ACCESS_KEY
AWS_S3_BUCKET_NAME
AWS_S3_ENDPOINT_URL
```

4. On your local machine, configure your RunPod key and the worker id.

You can run:

```
da configure runpod
```

Or set the following in your env:

```
RUNPOD_API_KEY
RUNPOD_OCR_ENDPOINT_ID
```

Usage is otherwise identical, just use `remote=True` with `pdf_document`
docketanalyzer-core 0.1.11
Docket Analyzer Core Utilities
Requires Python: >=3.10

[![Docs](https://img.shields.io/badge/docs-in%20progress-yellow)](https://docs.docketanalyzer.com/api/main/)

# Docket Analyzer Core

Core utilities for Docket Analyzer modules

Full documentation available at [docs.docketanalyzer.com](https://docs.docketanalyzer.com)

## Install and Configure

Install docketanalyzer:

```
pip install `docketanalyzer[all]`
```

Run the configuration script:

```
da configure
```

## Load Configured Env

```
from docketanalyzer import env

print(env.VARIABLE_NAME)
```

## Service Clients

### Elasticsearch

```python
from docketanalyzer import load_elastic

es = load_elastic()
print(es.ping())
```

### Postgres

```python
from docketanalyzer_core import load_psql

db = load_psql()
print(db.status())
```

### Redis

```python
from docketanalyzer import load_redis

redis = load_redis()
print(redis.ping())
```

### S3

```python
from docketanalyzer import load_s3

s3 = load_s3()
print(s3.status())
```

## Registry

Example usage:

```python
from docketanalyzer import Registry, SomeBaseClass


class SomeRegistry(Registry):
    def find_filter(self, obj):
        return (
            isinstance(obj, type) and
            issubclass(obj, SomeBaseClass) and
            obj is not SomeBaseClass
        )


some_registry = SomeRegistry()

# Find subclasses of SomeBaseClass in this module
some_registry.find(recurse=True)

# Import these into the current namespace
some_registry.import_registered()
```
xlns 1.0.5
A configurable python package for Logarithmic Number System eXperimentation
Requires Python: >=3.8

# xlns
XLNS: a configurable python package for Logarithmic Number System eXperimentation


# Getting Started

It is recommended to create a python virtual environment for experimentation with the ``xlns`` package. Within that environment, ensure you have the dependencies listed below installed.

Explanatory information about LNS is in the ``LNS_Intro.md`` file.  By default,  ``xlns`` uses 64-bit built-in floating point (FP) to calculate as accurately as is possible.  We call this approach _ideal_. The recent interest in LNS is mostly because there are many _non-ideal_ approximations which greatly reduce the cost of the hardware, and some of these methods are available here as _user configurations_.  Information on available user configurations can be found in the ``README.md`` file in ``src/xlnsconf``.  It also explains how you can contribute your own configurations to this open-source project.

# Dependencies
numpy

````
pip3 install numpy
````

For some examples, matplotlib is also needed:
````
pip3 install matplotlib
````

You can grab all the dependencies in one go using the requirements file thus:
````
pip install -r requirements.txt
````
twoaxistracking 0.2.7a2
twoaxistracking is a python package for simulating two-axis tracking solar collectors, particularly self-shading.
Requires Python: >=3.9
Keywords: solar energy, photovoltaics, solar collector, shading

# Open source code for calculating self-shading of two-axis tracking solar collectors
twoaxistracking is a python package for simulating two-axis tracking solar collectors, particularly self-shading.

## Documentation
The documentation can be found at [readthedocs](https://twoaxistracking.readthedocs.io/).

## Installation and dependencies
The package can be installed using pip:

    pip install twoaxistracking

## Citing
If you use the package in published work, please cite:
> Adam R. Jensen, Ioannis Sifnaios, and Kevin Anderson. "twoaxistracking – a python package for simulating
> self-shading of two-axis tracking solar collectors." MethodsX, 9, 101876, (2022).
> [https://doi.org/10.1016/j.mex.2022.101876](https://doi.org/10.1016/j.mex.2022.101876)

and

> Adam R. Jensen, Ioannis Sifnaios, Simon Furbo, and Janne Dragsted. "Self-shading of two-axis
> tracking solar collectors: Impact of field layout, latitude, and aperture shape." Solar
> Energy, 236, 215–224, (2022). [https://doi.org/10.1016/j.solener.2022.02.023](https://doi.org/10.1016/j.solener.2022.02.023)

## Contributing
Contributions to the repository, e.g., bug fixes and improvements to speed up the code are more than welcome.

## License
[BSD 3-clause](LICENSE).
lnr 0.2.0
Various linear regression modules

# lnr
Linear regression tools in python

---

This code incorporates various prescriptions for linear regression of measurements with uncertainties on both the dependent and independent variables which may be correlated. It also incorporates automatic conversions to logarithmic space in order to fit a power law, if so requested. See [Hogg, Bovy & Lang (2010)](https://arxiv.org/abs/1008.4686) for considerations on fitting a line to data.

Each function has a detailed help page but, briefly, the available functions are:

    lnr.bces(x1, x2, **kwargs)

Bivariate Correlated Errors and intrinsic Scatter (BCES, [Akritas & Bershady, 1996](http://adsabs.harvard.edu/abs/1996ApJ...470..706A)). Python code translated from [FORTRAN code](http://www.astro.wisc.edu/~mab/archive/stats/stats.html) by Christina Bird and Matthew Bershady.

    lnr.kelly(x1, x2, **kwargs)

Python wrapper around the [IDL Bayesian linear regression code](http://idlastro.gsfc.nasa.gov/ftp/pro/math/linmix_err.pro) by [Brandon Kelly (2007)](http://adsabs.harvard.edu/abs/2007ApJ...665.1489K), that accounts for correlated uncertainties in both variables and intrinsic scatter. Requires [`pIDLy`](https://github.com/anthonyjsmith/pIDLy) and an IDL license.

    lnr.mle(x1, x2, **kwargs)

Maximum likelihood estimator including intrinsic scatter.

    lnr.mcmc(x1, x2, **kwargs)

Perform an MCMC analysis, accounting for intrinsic scatter and using appropriate priors for each parameter (see, e.g., [this post](http://dfm.io/posts/fitting-a-plane/), or [this one](http://jakevdp.github.io/blog/2014/06/14/frequentism-and-bayesianism-4-bayesian-in-python/#Prior-on-Slope-and-Intercept). The MCMC sampling is performed with [`emcee`](http://dfm.io/emcee/current/).

##

There are additional, auxiliary functions:

    lnr.to_log(x, **kwargs)
    lnr.to_linear(logx, **kwargs)

convert a given set of measurements and uncertainties between linear and log space, and

    lnr.plot(t, a, b, **kwargs)

can be used to plot the best-fit linear relation along with a shaded region representing the best-fit uncertainties. Since this function can take a matplotlib axis as a keyword argument, it can be easily embedded within a larger plotting function that includes, for instance, the data points from which the relation is derived.

----

## **Installation**

Clone this package with

    git clone https://github.com/cristobal-sifon/lnr.git

(you may also fork it to your own github account and then clone your fork). Then, simply type

    python setup.py install [--user]

where the `--user` flag is recommended so that the installation takes place in the home directory and does not require root privileges.

After this, just open a python terminal and type

    >>> import lnr

and all the modules described above will be available. Then type, e.g.,

    >>> help(lnr.bces)

to get more details.

----

(c) Cristóbal Sifón
Last modified 2018-01-07
shear_psf_leakage 0.2.1
PSF leakage for shear catalogue data
Requires Python: <3.12,>=3.9

# Shear PSF leakage

## About

This library quantifies the PSF leakage on weak-lensing galaxy shear            
measurements. It computes the following quantities:                             
                                                                                
- The object-wise PSF leakage at linear and quadratic order, using regression.  
- The object-wise dependency of galaxy shear to other (scalar) observables.     
- The scale-dependent PSF leakage function galaxy - PSF leakage using           
  two-point correlation functions. 

## Installation

The fastest way to Install this library is with `pip` automatically from
pypi.org,

```bash
pip install shear_psf_leakage
```

Alternatively, you can use TBD

## Authors

Martin Kilbinger <martin.kilbinger@cea.fr>

Clara Bonini

Sacha Guerrini

Axel Guinot