semvec/pypi-packages huggingface dataset:
globy-webcrawlers 0.0.1
Globy Webcrawlers
Requires Python: >=3.9

# Globy webcrawlers
### :star: Scrape the world with Globy! :star:
## Usage
```bash
$ globy-scraper.py -h
usage: globy-scraper.py [-h] -f URLS_FILE [-l LOGLEVEL] [-o OUTPUT_FILE] [-d] [-s] [-b BACKEND]

options:
  -h, --help            show this help message and exit
  -f URLS_FILE, --urls_file URLS_FILE
                        Newline separated file of URLs to scrape
  -l LOGLEVEL, --loglevel LOGLEVEL
                        Set log level (1-3)
  -o OUTPUT_FILE, --output_file OUTPUT_FILE
                        Output CSV file path
  -d, --debug           Debug/inspect responses (Will set PYTHONINSPECT to True)
  -s, --store_html_to_file
                        Store HTML all content to file per domain in the "html_output" folder
  -b BACKEND, --backend BACKEND
      Select backend to use for scraping: "globy" (default) or "scrapy". 
      (!) The scrapy backend will only dump data to the "html_output" folder for now. No website analysis or other functionallity is supported yet.
```
## Quickstart
You can just run globy-scraper as a script (no installation needed):
```bash
pip3 install -r requirements.txt  # Install dependencies if not already installed
./globy-scraper.py -f wordpress-top50.txt
```
----
## Install the globy-webcrawlers package
You can install the package for development and use with other Globy projects.
It's **recommended** to set up a python virtual environment before installing the package.
```bash
pip3 install -e .
```
Now you can use the package in python:
```python
from globy_webcrawlers.crawler import WebSiteDataCrawler
>>> c = WebSiteDataCrawler()
>>> c.load_urls_from_file("urls.txt")
>>> c.run()
```
Also, after installing globy-scraper, you can just run it: `globy-scraper.py -h`

## Debugging/inspecting website content
Since the crawler is asynchronous, it can be a bit tricky to debug the responses. To make it easier, you can use the `-d` flag. This will allow you to inspect the HTML content and any internal objects from the most recent website.
Here's an example:
```bash
$ ./globy-scraper.py -f wordpress-top50.txt -d
```
```python
>>> w = crawler.debug_latest_response()
>>> w.url
'https://www.thyroid.org/'
>>> len(w.html_content)
249167
>>> w.get_website_info()
```
Change the crawler.urls to get the response you want to debug, or the input url list.


## Development only
Build and & create python package:
```bash
python3 -m build
```
decision-tool 1.0.3
Decision analysis package with solution and visualization.
Requires Python: >=3.6

# Project description
Decision-tool is a simple yet effective decision analysis tool. Solves and visualizes Trees with recursive algorithm.

## Usage
Decision trees are constructed using `Tree` class. it takes nested structure and returns a Tree instance. In the nested structure, dictinary represents decision, List represents discrete probability distribution and tuple represents possible outcome of a discrete probability distribution, scipy.stats can be used for continous probability distribution:


```
example_tree = Tree({"option 1":25,
                     "option 2":[(.4,20,"result 1"), (.3,21,"result 2"), (.3,stats.norm(1,1),"result 3")]
                     })
example_tree.fig().show()
```
![Image](https://i.imgur.com/TmRLdVp.png)




Consider the example: You have 2 options as quit the job and not quit. if you quit, you will get a bonus of 8000. If you do not quit, you will promote to manager with a probability of 0.3, If you then quit, will get 16000, If you do not, you will get a random payoff distributed normally with mean 12000 and standart deviation of 1000. If you do not quit at the begining and do not promote, your PV will be normal random variable with mean 10000 and standart deviation of 3000.

```
job_decision = Tree({
    "quit":8e3,
    "do not quit":[(0.3, 
                        {"quit":16e3,
                        "do not quit":stats.norm(12e3,1e3)
                        }
                    ,"promote"),

                    (0.7, stats.norm(10e3,3e3),"do not promote")
                    ]
})

job_decision.fig().show()
```
![Image](https://i.imgur.com/jxHMaBZ.png)

The method `solve` returns a Tree instance that only contains optimal solutions.
```
solution = job_decision.solve()
print("optimal expected monetary value:" ,solution.mean,"variance:",solution.var)
solution.fig().show()

    
```
    optimal expected monetary value: 11800.0 variance: 13860000.0
![Image](https://i.imgur.com/dEx2H6v.png)

For indexing, order decision names and event names:
```
print("Variance of not quiting and not getting a promote ",
      solution["do not quit","do not promote"].var)

```
    Variance of not quiting and not getting a promote  9000000.0

Save and load decision trees using `save` method and `load_tree` function.
jobapppy 0.1.0
Command-line tools and interfaces to generate formatted resume documents (markdown, tex, pdf, etc)
Requires Python: >=3.10,<3.12
Keywords: resume,template

# jobapppy

[![PyPI version](https://badge.fury.io/py/jobapppy.svg)](https://badge.fury.io/py/jobapppy)[![Python Versions](https://img.shields.io/pypi/pyversions/jobapppy?style=plastic)](https://pypi.org/project/jobapppy)
[![Main](https://github.com/cahna/jobapppy/actions/workflows/main.yaml/badge.svg)](https://github.com/cahna/jobapppy/actions/workflows/main.yaml)[![codecov](https://codecov.io/gh/cahna/jobapppy/graph/badge.svg?token=3XULKTDJ2I)](https://codecov.io/gh/cahna/jobapppy)

Command-line tools and interfaces to generate formatted resume documents (markdown, tex, pdf, etc).

Documentation: [https://cahna.github.io/jobapppy](https://cahna.github.io/jobapppy)

## CLI Usage

- via script name installed in path:
   ```console
   jobapppy --help
   ```
- as a python module:
   ```console
   python -m jobapppy --help
   ```

## Tutorial

1. Create a `resume.yaml` file that satisfies jobapppy's schema 
   - see `resume.example.yaml`
   - view the JSONSchema by running:
      ```console
      jobapppy schema -i2
      ```
2. (optional) Check that `resume.yaml` can be parsed:
   ```console
   jobapppy parse -c resume.yaml
   ```
3. Generate resume from templates:
   - Markdown (default, `-t md`)
      - Echo to stdout (default):
         ```console
         jobapppy template resume.yaml
         ```
      - Echo to file:
         ```console
         jobapppy template resume.yaml resume.md
         ```
   - Tex (`-t tex`)
      1. Generate `resume.tex`:
         ```console
         jobapppy template -t tex resume.yaml resume.tex
         ```
      2. Generate `resume.pdf`:
         ```console
         docker run --rm -it -v "$(pwd):/data" --net=none --user="$(id -u):$(id -g)" cahna/jobapp lualatex -synctex=1 -interaction=nonstopmode resume.tex
         ```
e2e-similarity 0.1
This is a package that utilizes OpenAI's powerful davinci-003 model to run Cypress tests, gather and parse the logs, and generate a comprehensive report. Users can specify their test directory when running the command. The package is designed to help developers automate their testing process and gain insights from the test logs.

# Project Name

A brief description of your project.

## Table of Contents

- [Installation](#installation)
- [Usage](#usage)
- [Contributing](#contributing)
- [License](#license)

## Installation

Instructions on how to install and set up your project.

## Usage

Instructions on how to use your project and any relevant examples.

## Contributing

Guidelines for contributing to your project and how others can get involved.

## License

Information about the license for your project.