Saravanan666/pypi-org huggingface dataset:
Package: camcalib
Camera Calibration w/ Python + OpenCVA wrapper around the main functionalities offered by OpenCV for camera calibration for cleaner and maintainable calibration routines.Dependenciesnumpy (1.17.4 preferred)
opencv (3.4.2 preferred)
tqdm##Installationpip install camcalibInstructionsImportfrom cam_calib import camera_calibrateSingle Camera CalibrationInstantiate an object of typecamera_calibrateby passing in relevant arguments to the constructor. (Example below uses some place holder arguments)camera_1 = camera_calibrate(img_path = './path', dims = (w, h), img_size = (w_i, h_i),...)Use thecalibmethod on the object for single camera calibrationparams = camera_1.calib()Stereo Camera CalibrationInstantiate two objects of the typecamera_calibrateby passing in relevant arguments to the constructor. (Example below uses some place holder arguments)camera_1 = camera_calibrate(img_path = '../left_path', dims = (w, h), img_size = (w_i, h_i),...)
camera_2 = camera_calibrate(img_path = '../right_path', dims = (w, h), img_size = (w_i, h_i),...)Call the class methodstereo_calibmethod on the classcamera_calibrateby passing the two objects as arguments.stereo_params = camera_calibrate.stereo_calib(camera_1, camera_2)
Package: camcrypt
= OVERVIEW =CamCrypt is a simple Python wrapper around one of the open sourceimplementations of the Camellia encryption library.  It makes use ofthe Python ctypes module to reference the functions available in theC library.= CAVEATS =The current version is only setup for Unix/Linux environments, butshould be easy to modify for MS-Windows for those familiar with thePython ctypes modules.= USAGE =First, compile the C code into a shared library:$ makeNext, copy the shared library and Python file to your project:$ cp camellia.so camcrypt.py DEST/Import the module into your script:import camcryptCreate a CamCrypt object, providing it the shared library path:mycrypt = camcrypt.CamCrypt(LIBRARY_PATH)Initialize the keytable with the number of key bits and a key/passphrase:mycrypt.keygen(128, "password")Encrypt in blocks of 16 bytes:ciphertext = mycrypt.encrypt(plaintext)Or decrypt in blocks of 16 bytes:plaintext = mycrypt.decrypt(ciphertext)= BASIC INFORMATION =Updates and contact information may be found on the project's website:https://github.com/knowmalware/camcryptCurrent version is 1.2.0, corresponding with the C implementationincluded with this module.  The C code was copied from:http://info.isl.ntt.co.jp/crypt/eng/camellia/dl/camellia-GPL-1.2.0.tar.gz
Package: camd
camd is software designed to support Computational Autonomy for Materials Discovery
based on ongoing work led by theToyota Research Institute.camd enables the construction of sequential learning pipelines using a set of
abstractions that includeAgents - decision making entities which select experiments to run from pre-determined
candidate setsExperiments - experimental procedures which augment candidate data in a way that
facilitates further experiment selectionAnalyzers - Post-processing procedures which frame experimental results in the context
of candidate or seed datasetsIn addition to these abstractions, camd provides a loop construct which executes
the sequence of hypothesize-experiment-analyze by the Agent, Experiment, and Analyzer,
respectively.  Simulations of agent performance can also be conducted using
after the fact sampling of known data.
Package: camdict
.. image:: https://travis-ci.org/prefer/camdict.svg?branch=master:target: https://travis-ci.org/prefer/camdict:alt: Tests.. image:: https://img.shields.io/coveralls/prefer/camdict.svg?style=flat:target: https://coveralls.io/r/prefer/camdict:alt: Coverage.. image:: https://pypip.in/version/camdict/badge.svg?style=flat&text=version:target: https://pypi.python.org/pypi/camdict/:alt: Latest Version.. image:: https://pypip.in/py_versions/camdict/badge.svg?style=flat&0:target: https://pypi.python.org/pypi/camdict/:alt: Supported Python versions.. image:: https://pypip.in/status/camdict/badge.svg?style=flat:target: https://pypi.python.org/pypi/camdict/:alt: Development Status.. image:: https://pypip.in/license/camdict/badge.svg?style=flat:target: https://pypi.python.org/pypi/camdict/:alt: LicenseAPI for `Cambridge Dictionaries Online <http://dictionary.cambridge.org/>`_--------------------------------Take a look to the tests for usage examples
Package: came
CAMEEnglish|简体中文CAME is a tool forCell-type Assignment and Module Extraction, based on a heterogeneous graph neural network.For detailed usage, please refer toCAME-Documentation.CAME outputs the quantitative cell-type assignment for each query cell, that is,
the probabilities of cell types that exist in the reference species, which
enables the identification of the unresolved cell states in the query data.Besides, CAME gives the aligned cell and gene embeddings across species, which
facilitates low-dimensional visualization and joint gene-module extraction.InstallationIt's recommended to create a conda environment for running CAME:condacreate-nenv_camepython=3.8
condaactivateenv_cameInstall required packages:# on CPUpipinstall"scanpy[leiden]"pipinstalltorch# >=1.8pipinstalldgl# tested on 0.7.2, better below 1.0.*SeeScanpy,PyTorchandDGLfor detailed installation guide (especially for GPU version).Install CAME by PyPI:pipinstallcameInstall the developmental version of CAME from source code:gitclonehttps://github.com/XingyanLiu/CAME.gitcdCAME
pythonsetup.pyinstallExample dataThe test code is based on the sample data attached to the CAME package.
It is initially saved in compressed form (CAME/came/sample_data.zip),
and will be automatically decompressed to the default directory
(CAME/came/sample_data/) when necessary, which contains the following files:gene_matches_1v1_human2mouse.csv (optional)gene_matches_1v1_mouse2human.csv (optional)gene_matches_human2mouse.csvgene_matches_mouse2human.csvraw-Baron_mouse.h5adraw-Baron_human.h5adYou can access these data bycame.load_example_data().If you tend to apply CAME to analyze your own datasets, you need to
prepare at least the last two files for the same species (e.g., cross-dataset
integration);For cross-species analysis, you need to provide another.csvfile where the first column contains the genes in the reference species and the
second contains the corresponding query homologous genes.NOTE:
the fileraw-Baron_human.h5adis a subsample from the original data
for code testing. The resulting annotation accuracy may not be as good as
using the full dataset as the reference.SuggestionsIf you have sufficient GPU memory, setting the hidden-sizeh_dim=512in "came/PARAMETERS.py" may result in a more accurate cell-type transfer.Test CAME's pipeline (optional)To test the package, run the python filetest_pipeline.py:# test_pipeline.pyimportcameif__name__=='__main__':came.__test1__(6,batch_size=2048)came.__test2__(6,batch_size=None)pythontest_pipeline.pyContributeIssue Tracker:https://github.com/XingyanLiu/CAME/issuesSource Code:https://github.com/zhanglabtools/CAMEhttps://github.com/XingyanLiu/CAME(the developmental version)SupportIf you are having issues, please let us know. We have a mailing list located at:544568643@qq.comxingyan@amss.ac.cnCitationIf CAME is useful for your research, consider citing our work:Liu X, Shen Q, Zhang S. Cross-species cell-type assignment of single-cell RNA-seq by a heterogeneous graph neural network[J]. Genome Research, 2022: gr. 276868.122.Preprint:https://doi.org/10.1101/2021.09.25.461790
Package: camect-py
Camect Python client library==============================The CamectSmart Camera Hubis an advanced network video recorder that uses
AI (Artificial Intelligence), private local video storage, and secure remote access to the networked
security cameras in your home. It plugs into your home network and provides 24×7 recording, viewing
from your home network, and AI-powered smart alert detection and review via the app.
You can learn more about camect atcamect.com.Installationpip3 install camect-pyUsagePlease openhttps://local.home.camect.com/in browser, sign in as admin and accept TOS before
you proceed.import camect
hub = camect.Hub("camect.local:443", "admin", "xxx")
hub.get_name()
hub.add_event_listener(lambda evt: print(evt))
for cam in home.list_cameras():
    print("%s(%s) @%s(%s)" % (cam["name"], cam["make"], cam["ip_addr"], cam["mac_addr"]))Disable / enable alertsimport camect
hub = camect.Hub("camect.local:443", "admin", "xxx")
hub.disable_alert(["yyy"], "testing")
....
hub.enable_alert(["yyy"], "testing")
Package: camel
Camel is a library that lets you describe how to serialize your objects to
YAML — and refuses to serialize them if you don’t.Quick example:fromcamelimportCamel,CamelRegistryclassDieRoll(tuple):def__new__(cls,a,b):returntuple.__new__(cls,[a,b])def__repr__(self):return"DieRoll(%s,%s)"%selfreg=CamelRegistry()@reg.dumper(DieRoll,u'roll',version=None)def_dump_dice(data):returnu"{}d{}".format(*data)@reg.loader(u'roll',version=None)def_load_dice(data,version):a,_,b=data.partition(u'd')returnDieRoll(int(a),int(b))value=DieRoll(3,6)camel=Camel([reg])print(camel.dump(value))# !roll 3d6# ...Docs:http://camel.readthedocs.org/en/latest/GitHub:https://github.com/eevee/camel
Package: camel-and-snake
# camel-and-snake## 🐫 and 🐍 ？？？🤣本项目旨在解决 camelCase 和 snake_case 相互转换的问题**支持 python3 以上版本**## 应用场景* 生成对 JavaScript 更友好的 `camelCase` 命名规范的 JSON 响应数据* 在 JSON 序列化之前将 `snake_case` 的字典转为 `camelCase`* 在 JSON 反序列化之后将 `camelCase` 的字典转回 `snake_case`## 如何使用？### 安装你可以通过 `pip` 来安装 `camel_and_snake`> 推荐使用 `pipenv` 在虚拟环境下安装```shell$ pip3 install camel_and_snake```### 使用```pythonfrom camel_and_snake import Converter```**snake_case -> camelCase**```pythondict_obj = {'org_id': 123,'org_name': 'ShadowCoder','member_list': [{'member_id': 1, 'member_name': 'Cphayim'},{'member_id': 2, 'member_name': 'Hoyoe'}]}# 转换过程中将对深层的每一个字典进行递归替换 key 值，并返回一个新的对象json.dumps(Converter.camelify(dict_obj), indent=2)"""{"orgId": 123,"orgName": "ShadowCoder","memberList": [{"memberId": 1,"memberName": "Cphayim"},{"memberId": 2,"memberName": "Hoyoe"}]}"""```**camelCase -> snake_case**```pythonjson_str = '{"orgId": 123, "orgName": "ShadowCoder", "memberList": [{"memberId": 1, "memberName": "Cphayim"}, {"memberId": 2, "memberName": "Hoyoe"}]}'dict_obj = Converter.snakeify(json.loads(json_str))# {'org_id': 123, 'org_name': 'ShadowCoder', 'member_list': [{'member_id': 1, 'member_name': 'Cphayim'}, {'member_id': 2, 'member_name': 'Hoyoe'}]}```## License[MIT](https://opensource.org/licenses/MIT)
Package: camelcalc
camelcalcA playable version ofCamel Up. As well as a (soon to exist) calculator to help determine what move a team should make.RequirementsPython 3.8+Friends to play withInstallationInstall with pippip install camelcalcThen play Camel Up by runningcamelupWhy?At the end of every semester, theCIS 120TA staff play Camel Up. I've been telling myself that I wanted to attempt to build a calculator for it, so here's my attempt.LicenseSeeLICENSE
Package: camelcase
Converts a string to Camel Case with the ability to include words to skip over.Basic Usage===========.. code:: pythonfrom camelcase import CamelCasec = CamelCase()s = 'this is a sentence that needs CamelCasing!'print c.hump(s)# This is a Sentence That Needs CamelCasing!If you have particular words that you want to skip then you can do the following..... code:: pythonfrom camelcase import CamelCasec = CamelCase('little', 'another')s = 'this is a another sentence, but this one is a little different'print c.hump(s)# This is a another Sentence, But This One is a little Different
Package: camelCasing
camelCasing PackageThis package converts Pascal Case and snake_case strings into its camelCase
equivalent.Installationpip install camelCasingBasic Usefrom camelCasing import camelCasing as ccIts functionality can be used in at least two ways:(1) Individually:# recode a single string
cc.toCamelCase(s='TheQuickBrownFox', user_acronyms=None)or (2) in list comprehensions:# get camelCase replacements for an arbitrary dataframe
[cc.toCamelCase(s=s, user_acronyms=None) for s in df.columns]User Defined AcronymsOne of the tricky problems facing camel case text generation is the problem
of acronyms. This package allows for user defined acronyms that the program
should look for and account for when creating its camelCase equivalent.Consider the following example:s = 'UefiDbx_UefiDbxKeyStatus'
cc.toCamelCase(s=s, user_acronyms=['WMI', 'FRU', 'SKU', 'UEFI'])  # UEFIDbxUEFIDbxKeyStatus

s = 'iaasByMicrosoft'
cc.toCamelCase(s=s, user_acronyms=['IaaS'])  # IaaSByMicrosoftThis functionality lets you have control over the acronyms that you want to keep and maintain.
Package: camel-converter
Camel ConverterIn JSON keys are frequently in camelCase format, while variable names in Python are typically
snake_case. The purpose of this pacakgae is to help convert between the two formats.UsageTo convert from camel case to snake case:fromcamel_converterimportto_snakesnake=to_snake("myString")This will convertmyStringintomy_stringTo convert a dictonary's keys from camel case to snake case:fromcamel_converterimportdict_to_snakesnake=dict_to_snake({"myString":"val 1"})This will convert{"myString": "val 1"}into{"my_string": "val 1"}. Non-string keys will be
left unchanged.This is also available as a decorator for functions that return a dictionary.fromcamel_converter.decoratorsimportdict_to_snake@dict_to_snakedefmy_func()->dict[str,str]:return{"myString":"val 1"}snake=my_func()my_funcwill return{"my_string": "val 1"}. Non-string keys will be
left unchanged.To convert from snake case to camel case:fromcamel_converterimportto_camelcamel=to_camel("my_string")This will convertmy_stringintomyStringTo convert from a dictionary's keys from snake case to camel case:fromcamel_converterimportdict_to_camelcamel=to_camel({"my_string":"val 1"})This will convert{"my_string": "val 1"}into{"myString": "val 1"}Non-string keys will be
left unchanged.This is also available as a decorator for functions that return a dictionary.fromcamel_converter.decoratorsimportdict_to_camel@dict_to_cameldefmy_func()->dict[str,str]:return{"my_string":"val 1"}camel=my_func()my_funcwill return{"myString": "val 1"}. Non-string keys will be
left unchanged.To convert from snake to pascal case:fromcamel_converterimportto_pascalpascal=to_pascal("my_string")This will convertmy_stringintoMyStringTo convert from a dictionary's keys from snake case to pascal case:fromcamel_converterimportdict_to_pascalpascal=to_pascal({"my_string":"val 1"})This will convert{"my_string": "val 1"}into{"MyString": "val 1"}Non-string keys will be
left unchanged.This is also available as a decorator for functions that return a dictionary.fromcamel_converter.decoratorsimportdict_to_pascal@dict_to_pascaldefmy_func()->dict[str,str]:return{"my_string":"val 1"}pascal=my_func()my_funcwill return{"MyString": "val 1"}. Non-string keys will be
left unchanged.Optional ExtrasAn optional extra is provided forPydanticthat provides a
base class to automatically convert between snake case and camel case. To use this Pydantic class
install camel converter with:pipinstallcamel-converter[pydantic]Then your Pydantic classes can inherit from CamelBase.fromcamel_converter.pydantic_baseimportCamelBaseclassMyModel(CamelBase):test_field:strmy_data=MyModel(**{"testField":"my value"})print(my_data.test_field)will result inmy valuebeing printed.With setting up your model in this waymyFieldfrom the source, i.e. JSON data, will map tomy_fieldin your model.ContributingIf you are interested in contributing to this project please see ourcontributing guide
Package: camelot-fork
Camelot ForkFeaturesTODORequirementsTODOInstallationYou can installCamelot ForkviapipfromPyPI:$pipinstallcamelot-forkUsagePlease see theCommand-line Referencefor details.ContributingContributions are very welcome.
To learn more, see theContributor Guide.LicenseDistributed under the terms of theMIT license,Camelot Forkis free and open source software.IssuesIf you encounter any problems,
pleasefile an issuealong with a detailed description.CreditsThis project was generated from@cjolowicz'sHypermodern Python Cookiecuttertemplate.
Package: camelot-py
Camelot: PDF Table Extraction for HumansCamelotis a Python library that can help you extract tables from PDFs!Note:You can also check outExcalibur, the web interface to Camelot!Here's how you can extract tables from PDFs.You can check out the PDF used in this examplehere.>>> import camelot
>>> tables = camelot.read_pdf('foo.pdf')
>>> tables
<TableList n=1>
>>> tables.export('foo.csv', f='csv', compress=True) # json, excel, html, markdown, sqlite
>>> tables[0]
<Table shape=(7, 7)>
>>> tables[0].parsing_report
{
    'accuracy': 99.02,
    'whitespace': 12.24,
    'order': 1,
    'page': 1
}
>>> tables[0].to_csv('foo.csv') # to_json, to_excel, to_html, to_markdown, to_sqlite
>>> tables[0].df # get a pandas DataFrame!Cycle NameKI (1/km)Distance (mi)Percent Fuel SavingsImproved SpeedDecreased AccelEliminate StopsDecreased Idle2012_23.301.35.9%9.5%29.2%17.4%2145_10.6811.22.4%0.1%9.5%2.7%4234_10.5958.78.5%1.3%8.5%3.3%2032_20.1757.821.7%0.3%2.7%1.2%4171_10.07173.958.1%1.6%2.1%0.5%Camelot also comes packaged with acommand-line interface!Note:Camelot only works with text-based PDFs and not scanned documents. (As Tabulaexplains, "If you can click and drag to select text in your table in a PDF viewer, then your PDF is text-based".)You can check out some frequently asked questionshere.Why Camelot?Configurability: Camelot gives you control over the table extraction process withtweakable settings.Metrics: You can discard bad tables based on metrics like accuracy and whitespace, without having to manually look at each table.Output: Each table is extracted into apandas DataFrame, which seamlessly integrates intoETL and data analysis workflows. You can also export tables to multiple formats, which include CSV, JSON, Excel, HTML, Markdown, and Sqlite.Seecomparison with similar libraries and tools.Support the developmentIf Camelot has helped you, please consider supporting its development with a one-time or monthly donationon OpenCollective.InstallationUsing condaThe easiest way to install Camelot is withconda, which is a package manager and environment management system for theAnacondadistribution.$ conda install -c conda-forge camelot-pyUsing pipAfterinstalling the dependencies(tkandghostscript), you can also just use pip to install Camelot:$ pip install "camelot-py[base]"From the source codeAfterinstalling the dependencies, clone the repo using:$ git clone https://www.github.com/camelot-dev/camelotand install Camelot using pip:$ cd camelot
$ pip install ".[base]"DocumentationThe documentation is available athttp://camelot-py.readthedocs.io/.Wrapperscamelot-phpprovides aPHPwrapper on Camelot.ContributingTheContributor's Guidehas detailed information about contributing issues, documentation, code, and tests.VersioningCamelot usesSemantic Versioning. For the available versions, see the tags on this repository. For the changelog, you can check outHISTORY.md.LicenseThis project is licensed under the MIT License, see theLICENSEfile for details.
Package: camels
The CAMELS datasetThis package provides an interface to the Catchment Attributes and Meteorology
for Large-sample Studies (CAMELS) dataset. This package only provides simplified
access to the data in Python, the actual work of generating the dataset has been
done by Andrew Newman and colleagues  at NCAR and is described in the following
article:A. Newman; K. Sampson; M. P. Clark; A. Bock; R. J. Viger; D. Blodgett, 2014. A
large-sample watershed-scale hydrometeorological dataset for the contiguous USA.
Boulder, CO: UCAR/NCARUsagePytorchfrom camels.pytorch import Streamflow
gauge_id = 13331500

training_data = Streamflow(gauge_id, "training")
validation_data = Streamflow(gauge_id, "validation")
test_data = Streamflow(gauge_id, "testing")
Package: camels-aus
CAMELS-AUS from pythonThis is currently a preview. You can contribute to features and designPython package to easily load and use the CAMELS-AUS dataset (Fowler, K. J. A. et al. 2020 (in review))CAMELS-AUS is the Australian edition of the Catchment Attributes and Meteorology for Large-sample Studies.Release notesv0.5: support loading more series and catchment attributes.v0.4: load minimal series for typical rainfall-runoff modellingLicenseBSD-3 (seeLicense)Source codeThe code repository is onGitHub.InstallationLinuxUsing a conda environment is recommended. To create a new environment:cd${HOME}/tmp
wgethttps://raw.githubusercontent.com/csiro-hydroinformatics/camels-aus-py/main/configs/camels_aus_environment.ymlmy_env_name=camels
condaenvcreate-n$my_env_name-f./camels_aus_environment.yml
condaactivate$my_env_nameThen:pipinstallcamels_ausIf installing from source, after checking out this git repo:pipinstall-rrequirements.txt# if not using condapythonsetup.pyinstallDevelopers:pythonsetup.pydevelopoptional: setting jupyter-laboptional but recommended: use mamba as a replacement for conda:conda install -c conda-forge --name ${my_env_name} mambamambainstall-cconda-forgejupyterlabipywidgetsjupyteripyleaflet
python-mipykernelinstall--user--name${my_env_name}--display-name"CAMELS"jupyter-lab.TroubleshootingNotebooksNormally jupyter-lab version 3.0 and more does not require explicit extensions installation, but if you have issues:if: "Loading widgets..."jupyter-labextensioninstall@jupyter-widgets/jupyterlab-managerif: "Error displaying widget: model not found"jupyter-labextensioninstall@jupyter-widgets/jupyterlab-manager
Package: camelsml
# Main code for my master thesis# Installation
- If you use pipenv and pyenv:` pipenv install-egit+https://github.com/bernharl/ealstm_regional_modeling_camels_gb.git#egg=camelsml--python3.8 `- If not using pipenv, this repository should be installable using pip as well.## Content of the repository
This repo is structured like a Python package. All relevant code is found within thecamelsmldirectory.## CitationAs you can see on the Github page, this repository is a fork of [this repository](https://github.com/kratzert/ealstm_regional_modeling).
Therefore, if you use this code, make sure to cite:` @article{kratzert2019universal, author = {Kratzert, F. and Klotz, D. and Shalev, G. and Klambauer, G. and Hochreiter, S. and Nearing,G.},title = {Towards learning universal, regional, and local hydrological behaviors via machine learning applied tolarge-sampledatasets}, journal = {Hydrology and Earth System Sciences}, volume = {23}, year = {2019}, number = {12}, pages ={5089--5110},url ={https://www.hydrol-earth-syst-sci.net/23/5089/2019/},doi ={10.5194/hess-23-5089-2019}} `, as well as the thesis connected to this code.## License
[Apache License 2.0](https://github.com/kratzert/ealstm_regional_modeling/blob/master/LICENSE)
Package: camelsnake
camelsnakecamelsnakeis a Python library for converting between camel case and snake case strings using regular expressions. It
provides two functions:camel_to_snake(camel_str: str) -> str: Converts a camel case string to a snake case string.snake_to_camel(snake_str: str) -> str: Converts a snake case string to a camel case string.InstallationTo installcamelsnake, simply usepip:pip install camelsnakeUsageTo usecamelsnake, import the library and call thecamel_to_snakeandsnake_to_camelfunctions with the
appropriate input strings. Here's an example:importcamelsnakecamel_str='HelloWorld'snake_str=camelsnake.camel_to_snake(camel_str)print(snake_str)# Output: 'hello_world'snake_str='my_http_request'camel_str=camelsnake.snake_to_camel(snake_str)print(camel_str)# Output: 'myHttpRequest'TestingTo run the tests forcamelsnake, installpytestand run the following command in the project directory:pytestThis will run the tests in thetest_camelsnake.pyfile and output the results.Licensecamelsnakeis licensed under the MIT License. See theLICENSEfile for more information.ContributingContributions tocamelsnakeare welcome! If you find a bug or would like to suggest a new feature, please open an
issue or submit a pull request. See theCONTRIBUTING.mdfile for more information.PS - I published this package in an attempt to see how ridiculous the task is that qualifies for a library of its own