Saravanan666/pypi-org huggingface dataset:
Package: croparray
croparrayAuthors: Tim Stasevich and Luis Aguilera.DescriptionThis module is intended for creating and manipulating an array of crops (or regions of interest) that were generated from a multicolor TIF video obtained from single-molecule microscopy.DocumentationDocumentation is accessible viacroparray.readthedocsColab implementationImplementation in Google ColabLocal installation from the Github repositoryInstallanaconda.Clone the Github repositorygitclonehttps://github.com/Colorado-State-University-Stasevich-Lab/croparray.gitTo create a virtual environment navigate to your local repository and use:condacreate-ncroparray_envpython=3.8-ysourceactivatecroparray_envTo install the rest of requirements use:pipinstall-rrequirements.txtTo install napari use:python-mpipinstall"napari[all]"Local installation using PIPTo create a virtual environment using:condacreate-ncroparray_envpython=3.8-ysourceactivatecroparray_envOpen the terminal and usepipfor the installation:pipinstallcroparrayTo install napari use:python-mpipinstall"napari[all]"Deactivating and removing the environmentTo deactivate or remove the environment from your computer use:condadeactivateTo remove the environment use:condaenvremove-ncroparray_envTo unistall croparray usepipuninstallcroparrayadditional troubleshooting informationIf you cannot see the package installed on your computer, try usingpip3. For example:pip3installcroparrayInstalling from yml envTo creating an environment file (yml) use:sourceactivatecroparray_env
condaenvexport>croparray_env.ymlToCreate an environment from this yml file.condaenvcreate-fcroparray_env.ymlUsageOrganizes crops and measurements of spots of interest from tif images in a convenient x-array format for reduced filesize and more open and reproducible analyses.Visualizes crops of detected spots from super-resolution microscope images.Calculates the best maximum projection for each crop containing a detected spot.Measures intensity of detected spots within crops.Calculates the correlation between two equal-length, 1D signals.Saves the crop array as a netcdf file at output_direction/output_filename.Integrates with Napari for fast and convenient review of crops of detected spots.Licenses for dependenciesLicense forNapari: BSD-3-Clause License. Copyright (c) 2018, Napari. All rights reserved.License forxarray: Apache License. Version 2.0, January 2004. Copyright 2014-2019, xarray Developers
Package: cropclassification
Crop classificationThis is a collection of scripts that can help to classify crops using Sentinel data.Probably this documentation won't suffice to get you started, but you are free to reach out for more info if you are really interested.In general, you should also be aware that the package isn't really meant to be an easy-to-use solution for crop classification. It is rather a quite specialised solution for our specific needs. Nonetheless we want to make the code public so if anyone is interested, they can have a look and possibly get some inspiration.Installation manualInstall condaAs the scripts are written in Python, you need to use a package manager to be able to install the packages the scripts depend on. The rest of the installation manual assumes you use anaconda and python 3.6+. The installer for anaconda can be found here:https://www.anaconda.com/download/.Create new environment and install dependenciesOnce you have anaconda installed, you can open an anaconda terminal window and follow the following steps:1. Create and activate a new conda environment
  ```
  conda create --name cropclassification
  conda activate cropclassification
  conda config --env --add channels conda-forge
  conda config --env --set channel_priority strict
  ```
  2. Install the dependencies for the crop classification scripts:
  ```
  conda install python=3.9 geopandas geofileops "h5py<3" openeo psutil qgis rasterio rasterstats scikit-learn
  ```
  3. If it was the first time you installed anaconda/geopandas, you might have to restart your computer to proceed
  4. Start the anaconda terminal window again and activate the environment
  ```
  conda activate cropclassification
  ```
  5. Now install cropclassification and dependencies that need pip with pip
  ```
  pip install cropclassification
  ```Calculate time seriesTo calculate time series, you need to runcropclassification -t <tasks_dir>, with a 'calc_timeseries' type of task in the tasks dir
on a server that has access to sentinel CARD images.Mind: the sentinel CARD image structure as expected for timeseries calculation depends on the image type:for Sentinel 2 images this is the standard S2 L2A format as available on the open acces copernicus hub.for Sentinel 1 backscatter and sentinel 1 coherence data this is a non-standardized data structure as there isn't a standard format (yet) for level 2 processed sentinel 1 images (as far as I know). Check out the code to see the expected data structure ;-).Start a crop classificationRuncropclassification -t <tasks_dir>, with a 'calc_marker' type of task in the tasks dir.
Package: crop-classifier
Unsupervised Crop-Classification using Multi-Spectral Satellite ImageryThis Project is used for crop classification using unsupervised Machine Leaning (K-Means clustering)Installation -
Install the package (python 3.0 and above):pip install crop-classifierHow to use -
from unsupcc import executer# getting indices layer stack for an AOI
    ie = executer.IndexExecuter()
    ie.get_layer_stack()
#provide the asked input and it will return the path where layer stack is stored

# get crop clusters from layer stack of multiple dates
    ce = executer.ClusterExecuter()
    ce.crop_classifier(indice_stack_path, date_bands, number_of_clusters)
#It will return a raster containing clusters of multiple cropsFor a manual installation get this package:wget https://github.com/Dehaat/crop-classification
cd crop-classificationInstall the package (python 3.0 and above):python setup.py install
Package: cropgbm
# Welcome to CropGBM！Crop Genomic Breeding machine (CropGBM) is a multifunctional program that integrates data preprocessing, population structure analysis, SNP selection, phenotype prediction, and data visualization. Has the following advantages:Use LightGBM algorithm to quickly and accurately predict phenotype values and support GPU-accelerated training.Supports selection and visualization of SNPs that are strongly related to phenotype.Support PCA and t-SNE two dimensionality reduction algorithms to extract SNP information.Support Kmeans and OPTICS two clustering algorithms to analyze the sample population structure.Plot histograms of heterozygosity rate, deletion rate, and frequency of alleles for genotype data.English version documentation: [https://ibreeding.github.io](https://ibreeding.github.io)Chinese version documentation: [https://ibreeding-ch.github.io](https://ibreeding-ch.github.io)Download link: [https://github.com/YuetongXU/CropGBM](https://github.com/YuetongXU/CropGBM)Cite:Contact us:cropgbm@163.comNote: Academic users can download directly, industrial users first contact us.
Package: cropimage
cropimagecropimage is a simple toolkit for image cropping. Different from other projects that mainly tackle face region, we extend to all kinds of images such as landscape. We support horizontal and portrait size and generate a square output.InstallationpipinstallcropimageGet StartedfromcropimageimportCroppercropper=Cropper()# Get a Numpy array of the cropped image# Set completeness to be False if you expect the 'person' to be complete rather than 'face'# Set target_size to be a tuple (size, size), only square output is supported now,result=cropper.crop('./images/input.jpg')# Save the cropped imagecv2.imwrite('cropped.jpg',result)More ResultsContributingIf you find any issue of this project, feel free to open an issue or contribute!
Package: cropimage-dh
cropimageCropImage is a simple toolkit for image cropping. Different from other projects that mainly tackle face region, we extend to all kinds of images such as landscape. We support horizontal and portrait size and generate a square output.InstallationpipinstallcropimageGet StartedfromcropimageimportCroppercropper=Cropper()# Get a Numpy array of the cropped image# Set completeness to be True if you expect the 'face' to be focused rather than 'person'# Set target_size to be a tuple (size, size), only square output is supported nowresult=cropper.crop('./images/input.jpg')# Save the cropped imagecv2.imwrite('cropped.jpg',result)More ResultsContributingIf you find any issue of this project, feel free to open an issue or contribute!
Package: cropin-plotrisk-insight-client
Cropin Plotrisk-Insight Client has functions to fetch plots, satellite, weather and yield details. It also exposes the plot image download function.Important Definitions
Plot - A piece of land, represented by geojson structure i.e. Polygon, Multipolygon or a circle.Satellite Data - For the plot created, satellite insights will be generated.Yield - Yield mapping refers to the process of collecting georeferenced data on crop yield and characteristics, such as moisture content, while the crop is being harvested with an onboard yield monitor.Weather - Weather data provides information about the weather and climate of a plot.GDD - GDD (Cumulative growing degree days) is an index calculated from temperature data and is used to estimate the time needed for a crop or other organisms to reach a certain stage of development.Prerequisites
1. Supported Python Version - This SDK has been tested with Python versions 3.5+. Earlier Python 3 versions are expected to work as well, as long as the dependencies are fulfilled.Users who have already onboarded onto sf_plus, enabled plotrisk feature for atleast few plots will be able use this SDK.
Package: cropmask
CropMask is a project to train and deploy instance segmentation models for mapping center pivot agriculture from multispectral satellite imagery. It extendsmatterport's module, which is an implementation ofMask R-CNNon Python 3, Keras, and TensorFlow. CropMask work with multispectral satellite imagery, contains infrastructure-as-code via terraform to provision a testing cluster on Azure, and will eventually contain a Leaflet or OpenLayers web app to expose maps of crop water use in drylands across the globe.Seematterport's mrcnn repofor an explanation of the Mask R-CNN architecture and a general guide to notebook tutorials and notebooks for inspecting model inputs and outputs.For an overview of the project in poster form, see this poster I presented at the Fall 2018 Meeting onCenter Pivot Crop Water Use.Below are Preliminary results from test on 2004 Landsat SR scene over western Nebraska. Detections are in Red, Targets from the Nebraska Department of Agriculture are in Green. Metrics are (probability score)/(intersection over union)Local Installation of cropmask dependencies, seeterraform/folder for instructions to set up azure components.Install dependencies and install the packagecondaenvcreate-fcropmask-env.yml
pythonsetup.pyinstall# use develop instead of install for editable modeCreate a file called.lsruat~and fill in your NASA Earth Explorer Login credentials[usgs]
username=
password=Copy theazure_configs_template.yaml, name itazure_configs.yamland place it outside of the git repository (so you don't accidently commit it). Fill it in according to the comments int he template.Download theNational WBD DatasetFind the watershed you'd like to get Landsat imagery for with thistool. Make note of the HUC ID and the HUC level (the number of digits in the HUC ID) and put these in your azure_config.yaml fileDownload pre-trained COCO weights (mask_rcnn_coco.h5) from thereleases page.(Optional) To train or test on MS COCO installpycocotoolsfrom one of these repos. They are forks of the original pycocotools with fixes for Python3 and Windows (the official repo doesn't seem to be active anymore).Linux:https://github.com/waleedka/cocoWindows:https://github.com/philferriere/cocoapi.
You must have the Visual C++ 2015 build tools on your path (see the repo for additional details)To train using labels from theNebraska 2005 Center Pivots Datasetand define the projection as Nebraska State Plane NAD 1983 in US Feet, which is EPSG code 102704This setup will allow you to run the parts of the project that don't require Azure, like locally downloading Landsat products according to watershed boundaries. For instructions on setting up the entire project on Azure, see the README in the terraform folder
Package: cropper
cropperdoes exactly what it says on the tin: it cuts up an image into
smaller pieces. In particular, it lets you pull as many overlapping sections
out of an image as you’d like.Dependencies:PythonGTKPyGTK, PyGlib, and PyCairoPython Imaging LibraryUnder Ubunutu, all of these packages are installed by default.cropper is known to run on Windows 7, but it is not well tested.If you find bugs, please report them to thebug tracker.
Package: cropresize
cropresize usesPILto crop and resize an image as appropriate for web
presentation. cropresize is a convenience package that allows image
resizing without aspect ratio distortion.APIcropresize contains one useful function,cropresize.crop_resize.
The function takes three arguments:image: aPIL imageobjectsize: a 2-tuple of (width,height);  at least one must be specifiedexact_size: whether to scale up for smaller imagesSeecropresize.crop_resize.__doc__for the function
documentation.crop_resizereturns the cropped and resized PIL image.Command LineThe command line program,crop-resize, is included in this python
package.  The help for the program is displayed by runningcrop-resizewith no arguments orcrop-resize--help.Future Workcropresize is written as a convenience function to PIL as this
methodology for cropping and resizing images is often desired for
presentation, particularly on the web.  Since the utility is in
demand, the functionality should be ported upstream to PIL.–http://k0s.org/portfolio/software.html#cropresize
Package: crop-utils
为了区分3.0与4.0版本，同时资源图与详情页也共用的一套裁剪逻辑代码。为了降低裁剪部分维护与开发难度，封装为裁剪工具包包制作流程环境：winpython版本: 3.9自定义包https://packaging.python.org/tutorials/packaging-projects/#项目目录结构ecpro-util/

 	|-- src/

 	|   |-- ecpro/

 	|   |  |-- init.py

 	|   |  |-- html_slot_config.py

 	|   |  |-- image.py

 	|   |  |-- img_crop.py

 	|--tests/

 	|   |--test.py

 	|--setup.py

 	|--LICENSE

 	|--MANIFEST.IN

 	|--pyproject.toml

 	|--READNE.md打包python setup.py sdist bdist_wheel发布到pypi首先需要在pypi上注册并绑定邮箱才有权限上传twine upload dist/*安装pip install crop-utils==4.3.31 -ihttps://pypi.python.org/simple/
Package: crop-video
Installationpipinstallcrop_videoUse by CLI# video_path start_time end_time save_path$crop_video1.mp400:00:0000:00:20result.mp4Use by pythonfromcrop_videoimportCropVideocutter=CropVideo()video_path="tests/test_files/1.mp4"cutter(video_path,"00:00:00","00:00:10","output/2.mp4")
Package: cropy
Command line tool and module to crop an image to a specific resolution removing less important parts first.First started with the approch of this publication but seems a bit complex and slow (http://research.microsoft.com/en-us/um/people/jiansun/papers/SalientDetection_CVPR07.pdf).cropy uses entropy information to identify slices of the image with less informations.UsageTo use with command line:cropy -i [input image] -r [width] [height] -o [output name] -s [maxSteps]input image : location of the image to cropwidth, eight : dimensions of the resultant cropped imageoutput name : name of the output image (default : original_name.width.eight.orginal_extension)maxSteps : number of iteration : greater means more precision but slower (default : 10)More info and examples onhttp://blog.mapado.com/cropy-how-to-crop-an-image-keeping-the-best-content/InstallationYou can install cropy using pip:$ pip install cropyNote that cropy requiresscikit-learn, which itself is based onnumpyandscipyand requirescythonto compile.Possible upgradelocate faces inside image to prevent removinglocate text on images to crop firstThanksInspired from slycrop (php entropy based crop) :https://github.com/stojg/slycrop
Package: croshell
Welcome to DotfilesDotfiles is a repo for managing dotfiles. The idea is to collect those time-consuming files to setup in one directory and reference them via symbolic links from there original locations. Thus, when a new machine is required to be setup, all that is required to clone the repo in that machine and create the symbolic links.Dotfiles include, but are not limited to:~/.gitconfig~/.ssh~/.aws~/.bash_profile~/.bashrc$profilein Windows PowershelletcAdditionally, files that contain data, sensitive information that should not be pushed to a repository are contained in a directory~/dotfiles(not to be confused with name of this repo which lives in~/code/dotfiles) and are referenced from here. The files therein are encrypted before backedup.Additionally, scripts to perform setup of new machines and perform mundane tasks are maintained here inscripts. The repo uses Python to perform the tasks.
Package: cross43
CLOUD AUDIT TOOLCloud Audit tool helps you to check whether the application built on AWS is following the AWS Well-Architected framework by validating it against
various AWS services security requirements and the best practices. Generates report to validate the security requirements and security best practices.Cloud Audit tool setupThe project basically uses boto client to connect to the aws services.Update the session credentials in the terminal or give them through the arguments in the command line by specifying --access-key, --secret-key, and --session-token.While running the program, You can specify the region name, config file path, report file path, and tags through --region, --config-path, -report-path arguments.If no region is specified us-east-1 is taken as the default region, Similarly if no config file path and report path are given, the current working directory's path is taken as the default path and the audit checks are performed for the default values.Tags are checked by passing as an argument --tags or updating account tags in the config.json file. Moreover, the tags passed through the argument in the command line take priority.The format of the tags that are passed through the argument in the command line should be separated using commas (,).Cloud Audit Tool ExecutionCommand to Run the audit tool in the command line after installing the package.cloud-audit-toolArguments that can be passedcloud-audit-tool --region {region-name} --config-path {config-path} --report-path {report-path} --access-key {access-key} --secret-key {secret-key} --session-token {session-token} --tags {tag1,tag2,..}Final ReportThe overall report is provided as a HTML document in the path specified in the report-path argument. If no path is specified report is generated in the current working directory.
Package: crossabc
crossabcEasily CrossABC analyzerUsagefromcrossabcimportCrossABCimportpandasaspddf=pd.DataFrame(data={"sales":{"item_1":30750,"item_2":29000},"profit":{"item_1":8900,"item_2":3430}})c=CrossABC(df=df,indicators=["sales","profit"])ans_df=c.get_df()Whendfissalesprofititem_1307508900item_2290003430and useCrossABC(df, ["sales", "profit"]), nowans_dfissalesprofitrank_salesrank_profititem_130750890068item_22900034301010BuildThe source code is currently hosted on GitHub at:https://github.com/hrt0809/crossabc. Binary installers for the latest released version are available at thePyPI.pip install crossabcDependencieshttps://numpy.orghttps://pandas.pydata.org
Package: crossandra
CrossandraCrossandra is a fast and simple tokenization library for Python operating on
enums and regular expressions, with a decent amount of configuration.InstallationCrossandra is available on PyPI and can be installed with pip, or any other
Python package manager:$pipinstallcrossandra(Some systems may require you to usepip3,python -m pip, orpy -m pipinstead)LicenseCrossandra is licensed under the MIT License.DocumentationExamplesfromenumimportEnumfromcrossandraimportCrossandraclassBrainfuck(Enum):ADD="+"SUB="-"LEFT="<"RIGHT=">"READ=","WRITE="."BEGIN_LOOP="["END_LOOP="]"bf=Crossandra(Brainfuck,suppress_unknown=True)print(*bf.tokenize("cat program: ,[.,]"),sep="\n")# Brainfuck.READ# Brainfuck.BEGIN_LOOP# Brainfuck.WRITE# Brainfuck.READ# Brainfuck.END_LOOPfromcrossandraimportCrossandra,Rule,commondefhex2rgb(hex_color:str)->tuple[int,int,int]:r,g,b=(int(hex_color[i:i+2],16)foriinrange(1,6,2))returnr,g,bt=Crossandra(ignore_whitespace=True,rules=[Rule(r"#[0-9a-fA-F]+",hex2rgb),common.WORD])text="My favorite color is #facade"print(t.tokenize(text))# ['My', 'favorite', 'color', 'is', (250, 202, 222)]# Supporting Samarium's numbers and arithmetic operatorsfromenumimportEnumfromcrossandraimportCrossandra,Ruledefsm_int(string:str)->int:returnint(string.replace("/","1").replace("\\","0"),2)classOp(Enum):ADD="+"SUB="-"MUL="++"DIV="--"POW="+++"MOD="---"sm=Crossandra(Op,ignore_whitespace=True,rules=[Rule(r"(?:\\|/)+",sm_int)])print(*sm.tokenize(r"//\ ++ /\\/ --- /\/\/ - ///"))# 6 Op.MUL 9 Op.MOD 21 Op.SUB 7If you have any questions, or would like to get in touch, join myDiscord server!
Package: cross-attn
MultiModalCrossAttnThe open source implementation of the cross attention mechanism from the paper: "JOINTLY TRAINING LARGE AUTOREGRESSIVE MULTIMODAL MODELS"Paper LinkAppreciationLucidrainsAgoriansInstallpip install cross-attnUsageimporttorchfromcross_attn.mainimportMultiModalCrossAttention# Test the MultiModalCrossAttention moduledim=512# For examplenum_heads=8cross_attn=MultiModalCrossAttention(dim,num_heads)Hllm_sample=torch.randn(32,dim,dim)# Batch size = 32, Sequence length = 10Himg_sample=torch.randn(32,dim,dim)output=cross_attn(Hllm_sample,Himg_sample)print(output)print(output.shape)# Expected: [32, 10, 512]LicenseMITCitations@misc{2309.15564,
Author = {Emanuele Aiello and Lili Yu and Yixin Nie and Armen Aghajanyan and Barlas Oguz},
Title = {Jointly Training Large Autoregressive Multimodal Models},
Year = {2023},
Eprint = {arXiv:2309.15564},
}
Package: cross-aws-account-iam-role
Welcome tocross_aws_account_iam_roleDocumentationThe best practice to setup AWS Account is using IAM assumed roles. You can grant an AWS Account (IAM root), an IAM User or an IAM Role to assume an IAM Role in another AWS Account. This is the most secure way to access AWS resources across AWS Accounts.This Python tool can setup / modify / cleanup cross AWS account IAM permission at scale. See usage example below:Grant IAM Root (entire AWS account) cross account IAM permissionGrant IAM User cross account IAM permissionGrant IAM Role cross account IAM permissionInstallcross_aws_account_iam_roleis released on PyPI, so all you need is to:$pipinstallcross-aws-account-iam-roleTo upgrade to latest version:$pipinstall--upgradecross-aws-account-iam-role
Package: crossbar
Decentralized MiddlewareCrossbar.iois an open source networking platform for distributed and microservice applications. It implements the open Web Application Messaging Protocol (WAMP), is feature rich, scalable, robust and secure. Let Crossbar.io take care of the hard parts of messaging so you can focus on your app’s features.ResourcesDownload fromPyPIRead more on theProject HomepageJump into theGetting StartedRead the referenceDocumentationJoin theUser forumAsk a question onStackOverflowRead ourLegal NotesDocker imagesamd64armv7armv8JSON Schema for Crossbar.io Configuration File FormatWe now have a JSON Schema file available forconfig.json, if you’re using VSCode you can make
use of this by adding the following to your VSCode settings; (File -> Preferences -> Settings)"json.schemas":[{"fileMatch":["/config.json","/.config.json"],"url":"https://raw.githubusercontent.com/crossbario/crossbar/master/crossbar.json"}],Alternatively, the generic approach is to insert a “$schema” line at the top of your file;{"$schema":"https://raw.githubusercontent.com/crossbario/crossbar/master/crossbar.json","version":2,This file is currently experimental, but it should give you contextual auto-completion on
all Crossbarconfig.jsonsyntax, use CTRL+Space in VSCode to activate IntelliSense.Copyright (C) 2013-2021 Crossbar.io Technologies GmbH. All rights reserved.
WAMP, Crossbar.io and XBR are trademarks of Crossbar.io Technologies GmbH.