semvec/pypi-packages huggingface dataset:
LensToZotero 0.1.4
A package to transfer Lens publications in csv format to Zotero

# LensToZotero

Transfer Lens publications in csv format to Zotero

# Quickstart

1. `pip install LensToZotero`
2. You'll need the ID of the personal or group library you want to access:
   - Your **personal library ID** is available [here](https://www.zotero.org/settings/keys), in the section `Your userID for use in API calls`
   - For **group libraries**, the ID can be found by opening the group's page: `https://www.zotero.org/groups/groupname`, and hovering over the `group settings` link. The ID is the integer after `/groups/`
3. You'll also need<sup>вЂ </sup> to get an **API key** [here](https://www.zotero.org/settings/keys/new):
   - Press "Allow write access" button, when you create your key
4. Are you accessing your own Zotero library? `library_type` is `'user'`
5. Are you accessing a shared group library? `library_type` is `'group'`.

Then create a file settings.txt:

```txt
filePath doc_name.csv
library_id your_id
library_type user
api_key your_api_key
```

And place setting.txt and doc_name.csv near the root of the called function.

# Using

Example:

```python
from LensToZotero.LensToZotero import transfer

transfer("settings.txt")
```
box-cmd 2.0.3
A command-line tool to easily create backups of selected folders or files.
Requires Python: >=3.7

# BOX

Box is a command line tool that enables the easy creation of rolling backups using user-defined presets.

## Installation

### Pre-Installation

Ensure you have the following tools configured and working on your machine.
- Python (3.7 or greater)
- Git

Follow these steps to install this utility.

1. Clone the repository using git:
	- `git clone https://github.com/InValidFire/backup_cmd.git` (https)
	- `git clone git@github.com:InValidFire/backup_cmd.git` (ssh)
2. Navigate into the root of the repository.
3. Use pip to install the package locally.
	- `python -m pip install .`

> Note: Depending on your system's configuration, the exact commands to run may vary.

### Post-Installation and Configuration

BOX loads a file in your HOME directory called `.box_config.json`, it should have the following structure:

```json
{
	"format": 1,
	"presets": {
		"<preset_name>": {
			"targets": [
				"C:\\Target\\Path\\One",
				"C:\\Target\\Path\\Two"
			],
			"destinations": [
				{
					"path": "E:\\Destination\\Path",
					"file_format": "zip",
					"name_separator": "-",
					"date_format": "%d_%m_%y__%H%M%S",
					"max_backup_count": 10
				}
			]
		}
	}
}
```

> If you'd like to see the JSON Schema used to validate this file, see here: [presets.json JSON Schema](docs/presets_schema.json)

---

## Usage
`box list` - list all presets found in the config file.

`box pack [--force] [--keep] <preset>` - create a backup using the `preset`. if the `force` flag is set, force the backup creation even if it was already saved. if the `keep` flag is set, keep backups beyond the max_backup_count.

`box unpack --source=<preset|backups_folder> [--destination <destination_path>]` - select a backup to restore from the `preset` or `backups_folder` path. The `backups_folder` path should contain completed backups from the utility. If the `destination` is given, the original backup's target will not be used and the backup will instead be restored to the custom destination.

## Development and Contribution

To run the program in a development environment, first install the program using pip.

`pip install -e <repo-directory>`

Then you can run the command under the `box` command name. :)

---

This program utilizes `pytest` for testing, with `pytest-cov`, ensure you have them both installed:

`pip install pytest pytest-cov`

To run all tests in the tests directory, run the following command in the repo root directory.

`pytest --cov=box_cmd ./tests`

If you'd like the report to be generated into an HTML document (for detailed information), run this command instead:

`pytest --cov=box_cmd ./tests --cov-report=html`
sqlalchemy-window 0.2.0
A SQLAlchemy plugin to add support for PostgreSQL WINDOW clause
Requires Python: >=3.8

# sqlalchemy_window

A SQLAlchemy plugin to add support for PostgreSQL WINDOW clause.

**NOTE**: only supports SQLAlchemy 2.0 and higher.

## Example

Newer versions (>= 0.1.3) allow you to use `Window.over_self` interface
for window functions:

```py
import sqlalchemy as sa
from sqlalchemy_window import select, window

metadata = sa.MetaData()
table = sa.Table(
  "prices",
  metadata,
  sa.Column("asset", sa.String(16), primary_key=True),
  sa.Column("ts", sa.DateTime(timezone=True), primary_key=True),
  sa.Column("price", sa.Numeric, nullable=False),
)

w = window("w", partition_by=table.c["asset"], order_by=table.c["ts"], range_=(None, None))

query = select(
  w.over_self(sa.func.first_value(table.c["price"])).label("open"),
  w.over_self(sa.func.max(table.c["price"])).label("high"),
  w.over_self(sa.func.min(table.c["price"])).label("low"),
  w.over_self(sa.func.last_value(table.c["price"])).label("close"),
).where(sa.func.cast(table.c["ts"], sa.Date) == '2023-01-01').window(w)
```

Before that, to build above query you would use `over_window` factory:

```py
query = select(
  over_window(sa.func.first_value(table.c["price"]), w).label("open"),
  over_window(sa.func.max(table.c["price"]), w).label("high"),
  over_window(sa.func.min(table.c["price"]), w).label("low"),
  over_window(sa.func.last_value(table.c["price"]), w).label("close"),
).where(sa.func.cast(table.c["ts"], sa.Date) == '2023-01-01').window(w)
```

You can still use `over_window` in newer versions.

## Development

To setup a development environment run:

```bash
python3 -m venv venv
source ./venv/bin/activate
pip install --upgrade pip
pip install -r dev-requirements.txt -e .
pre-commit install
```

Running tests:

```bash
make test
make coverage
```

---

A waterfountain1996 project.
shela-shelo 0.0.1
A small example package
Requires Python: >=3.6


# Make sure you have upgraded version of pip
Windows
```
py -m pip install --upgrade pip
```

Linux/MAC OS
```
python3 -m pip install --upgrade pip
```

## Create a project with the following structure
```
packaging_tutorial/
├── LICENSE
├── pyproject.toml
├── README.md
├── setup.cfg
├── src/
│   └── example_package/
│       ├── __init__.py
│       └── example.py
└── tests/
touch LICENSE
touch pyproject.toml
touch setup.cfg
mkdir src/mypackage
touch src/mypackage/__init__.py
touch src/mypackage/main.py
mkdir tests
```

## pyproject.toml 

This file tells tools like pip and build how to create your project

```
[build-system]
requires = [
    "setuptools>=42",
    "wheel"
]
build-backend = "setuptools.build_meta"
```
build-system.requires gives a list of packages that are needed to build your package. Listing something here will only make it available during the build, not after it is installed.

build-system.build-backend is the name of Python object that will be used to perform the build. If you were to use a different build system, such as flit or poetry, those would go here, and the configuration details would be completely different than the setuptools configuration described below.


# Setup.cfg setup
Using setup.cfg is a best practice, but you could have a dynamic setup file using setup.py

```
[metadata]
name = example-pkg-YOUR-USERNAME-HERE
version = 0.0.1
author = Example Author
author_email = author@example.com
description = A small example package
long_description = file: README.md
long_description_content_type = text/markdown
url = https://github.com/pypa/sampleproject
project_urls =
    Bug Tracker = https://github.com/pypa/sampleproject/issues
classifiers =
    Programming Language :: Python :: 3
    License :: OSI Approved :: MIT License
    Operating System :: OS Independent

[options]
package_dir =
    = src
packages = find:
python_requires = >=3.6

[options.packages.find]
where = src

```
# Running the build
### Make sure your build tool is up to date
Windows
```
py -m pip install --upgrade build
```
Linux/MAC OS
```
python3 -m pip install --upgrade build
```


### Create the build
```
py -m build
```

### Upload to pypi
```
twine upload dist/*
```














### References
https://packaging.python.org/tutorials/packaging-projects/
wild-requests 0.0.5
Just a module that provides some tools for downloading.

Wild Requests is a versatile Python package designed to simplify HTTP requests using the powerful HTTPX library. With an intuitive interface and prebuilt logic, it streamlines the process of making web requests, making it an ideal choice for both beginners and experienced developers. Wild Requests supports various HTTP methods, handles authentication, and manages cookies effortlessly. Whether you're building web scrapers, API clients, or need to access web resources, Wild Requests offers a convenient and efficient solution.
python-tables 1.1.1
Tables from lua, in python
Requires Python: >=3.12

# Python-Tables
Implementing tables from Lua into Python 3.12

## Usage

```bash
pip install python-tables
```

```py
from tables import Table

tbl = Table()
print(tbl) # <>
tbl.append(1)
tbl["foo"] = "bar"
print(tbl) # <1, foo: 'bar'>

print(repr(tbl)) # Table([1]; {"foo": "bar"})
tbl += [2,3,4]
print(tbl) # <1, 2, 3, 4, foo: 'bar'>
print(tbl == Table(1,2,3,4,foo="bar"))
```