semvec/pypi-packages huggingface dataset:
ccic 0.1
Chalmers Cloud Ice Climatology
Requires Python: >=3.8

# The Chalmers Cloud Ice Climatology

This repository contains all source code for the training and processing of the
retrieval underlying the Chalmers Cloud Ice Climatology (CCIC) data record.

## Documentation

Documentation describing the CCIC data, its uses, and how to run the retrievals can be found [here](https://ccic.readthedocs.io/en/latest/intro.html).

## Data

At the time of writing, the [Registry of Open Data on AWS](https://registry.opendata.aws) contains all CCIC total ice water path estimates until 2023. The data can be found [here](https://registry.opendata.aws/ccic/).

## References

The CCIC retrieval, its implementation, and validation results are presented in Amell, A., Pfreundschuh, S., and Eriksson, P.: The Chalmers Cloud Ice Climatology: Retrieval implementation and validation, EGUsphere [preprint], [https://doi.org/10.5194/egusphere-2023-1953](https://doi.org/10.5194/egusphere-2023-1953), 2023.
OSMan2 0.1.0
#### Role:
Requires Python: >=3.6

### OSMan2
### Library Name: `OSMan2`

#### Role:
The `OSMan2` library provides a set of utility functions for file and directory management tasks such as creating, removing, renaming, and listing files and directories. It also includes functions for file operations like reading and writing, as well as retrieving system and environmental information.



#### Functions and Usage:

1. **`touch(File_Name)`**: Creates an empty file if it doesn't already exist.

   ```python
   import OSMan2

   print(Man_os2.touch("example.txt"))
   ```

2. **`cat(File_Name)`**: Reads the content of a file.

   ```python
   print(OSMan2.cat("example.txt"))
   ```

3. **`nano(File_Name, Mode, Write)`**: Writes content to a file. The mode can be 'w' (write) or 'a' (append).

   ```python
   print(OSMan2.nano("example.txt", "w", "Hello, world!"))
   ```

4. **`rm(File_Name)`**: Removes a file.

   ```python
   print(OSMan2.rm("example.txt"))
   ```

5. **`mkdir(Folder_Name)`**: Creates a new directory.

   ```python
   print(OSMan2.mkdir("new_folder"))
   ```

6. **`rmdir(Folder_Name)`**: Removes a directory.

   ```python
   print(OSMan2.rmdir("new_folder"))
   ```

7. **`ren(Name, New_Name)`**: Renames a file or directory.

   ```python
   print(OSMan2.ren("old_name.txt", "new_name.txt"))
   ```

8. **`mv(source_path, destination_path)`**: Moves a file or directory from one path to another.

   ```python
   print(OSMan2.mv("file.txt", "new_location/file.txt"))
   ```

9. **`cd(path)`**: Changes the current working directory.

   ```python
   print(OSMan2.cd("/path/to/directory"))
   ```

10. **`tree(chomain)`**: Lists all files and directories in a directory tree.

    ```python
    print(OSMan2.tree("."))
    ```

11. **`pwd()`**: Returns the current working directory.

    ```python
    print(OSMan2.pwd())
    ```

12. **`ls(path)`**: Lists files and directories in a specified path.

    ```python
    print(OSMan2.ls("."))
    ```

13. **`ls_l(path)`**: Lists files and directories with detailed information such as size and last modified time.

    ```python
    print(OSMan2.ls_l("."))
    ```

14. **`istime(path_Name)`**: Returns the last access time of a file.

    ```python
    print(OSMan2.istime("example.txt"))
    ```

15. **`size(path_Name)`**: Returns the size of a file.

    ```python
    print(OSMan2.size("example.txt"))
    ```

16. **`get_info()`**: Retrieves and returns system environmental variables.

    ```python
    print(OSMan2.get_info())
    ```

17. **`get_path()`**: Retrieves and returns executable paths.

    ```python
    print(OSMan2.get_path())
    ```
fastorm 0.0.17
FastORM framework, easy to learn, fast to code
Requires Python: >=3.10.0

# FastORM
### ORM for async postgres
##### Beta

FastORM is a modern, fast (async), database library for projects with Python 3.10+ based on standard Python type hints.

The key features are:
 - Async postgres
 - Tested to work with Python 3.10

#### Install
```
pip install fastorm
```

#### Example
> See [example.py](example.py) for more examples.

Let's define some tables, to show off the capabilities.

```py
class State(str, Enum):
    RUNNING = 'running'
    ABORTED = 'stopped'
    COMPLETED = 'done'
# end class


class User(FastORM):
    _ignored_fields = []
    _primary_keys = ['id']
    _automatic_fields = ['id']
    _table_name = 'user'

    id: Optional[int]  # Optional because automatically filled (_automatic_fields)
    name: str


class Auction(FastORM):
    _ignored_fields = []
    _primary_keys = ['id']
    _automatic_fields = ['id']
    _table_name = 'auction'

    id: Optional[int]  # Optional because automatically filled (_automatic_fields)
    owner: Union[int, User]  # can be provided by int or the native object
    previous_owner: Optional[User]  # Optional because nullable
    state: State  # Enum support :D
    title: str
    subtitle: Optional[str]  # nullable
    description: str
    start_date: datetime  # datetime support
    end_date: datetime
    metadata: JSONType
    deleted: bool
    chat_id: int
```

Now you can quickly write classes to the database:

```py
conn = await FastORM.create_connection('postgresql://user:password@postgres_host/database')


user = User(id=None, name="hunter24")  # id will be filled by the database
await owner_user.insert(conn=conn)  # set's the id, too.

auction = Auction(
    id=None,  # gonna be automatic if `insert(…, ignore_setting_automatic_fields=False)` (default).
    # two ways of setting references to other tables:
    # by the actual value, in this case the numeric id
    owner=user.id,  
    # or via a different object,
    # it will use the id field (internally set by `User._primary_keys`) to determine the actual values.
    previous_owner=user,  
    state=State.RUNNING,  # enum will be a string in the database
    title="I sell my soul", subtitle="Slightly used",
    description="You only get a share though, others claim ownership, too.",
    start_date=datetime.now(), end_date=datetime.now() + timedelta(days=5),  # datetimes just works
    metadata={"just": ["json", "stuff", 111, datetime.now()]},  # will be native JSONB. You can have datetimes and your own classes in there as well, see `FastORM._set_up_connection`.
    deleted=False,
    chat_id=9223372036854775807,  # note, this database field must be BIGINT for such large numbers
)
await auction.insert(conn=conn)
```

Basic lookups are easy, too.

```py
# single lookup, returns one element or None
user = await User.get(name="hunter24")
user = await User.get(id=1234)

# list of results (list can have length 0)
all_running_auctions = Auction.select(state=State.RUNNING)
```

Of course updating and deleting is possible too.

```py
auction.state = State.COMPLETED
await auction.update()
```
```py
await user.delete()
```